Exemplo n.º 1
0
def package_dict_save(pkg_dict, context):

    model = context["model"]
    package = context.get("package")
    allow_partial_update = context.get("allow_partial_update", False)
    if package:
        pkg_dict["id"] = package.id
    Package = model.Package

    if 'metadata_created' in pkg_dict:
        del pkg_dict['metadata_created']
    if 'metadata_modified' in pkg_dict:
        del pkg_dict['metadata_modified']

    pkg = table_dict_save(pkg_dict, Package, context)

    package_resource_list_save(pkg_dict.get("resources", []), pkg, context)
    package_tag_list_save(pkg_dict.get("tags", []), pkg, context)
    package_membership_list_save(pkg_dict.get("groups", []), pkg, context)

    subjects = pkg_dict.get('relationships_as_subject', [])
    relationship_list_save(subjects, pkg, 'relationships_as_subject', context)
    objects = pkg_dict.get('relationships_as_object', [])
    relationship_list_save(subjects, pkg, 'relationships_as_object', context)

    extras = package_extras_save(pkg_dict.get("extras", []), pkg, context)

    return pkg
def inventory_entry_bulk_create(context, data_dict):
    model = context['model']
    schema = context['schema']
    session = context['session']

    organization = model.Group.get(context['organization_name'])
    inventory_entry_dict = {'group_id': organization.id}

    if not data_dict['field-name-input-0']:
        raise ValidationError({'error': [_('Please add at least one inventory entry.')]})

    for inventory_entry_id in range(10):
        inventory_entry_name = data_dict['field-name-input-' + str(inventory_entry_id)]
        if not inventory_entry_name:
            break

        inventory_entry_dict['title'] = inventory_entry_name
        inventory_entry_dict['recurring_interval'] = data_dict['field-recurring-input-' + str(inventory_entry_id)]
        inventory_entry_dict['is_recurring'] = (inventory_entry_dict['recurring_interval'] != '0')

        data, errors = navl_validate(inventory_entry_dict, schema, context)

        if errors:
            session.rollback()
            # TODO @palcu: i18n
            raise ValidationError({'error': [_('Verificati intrarea cu numarul {0}.'.format(inventory_entry_id+1))]})

        obj = table_dict_save(inventory_entry_dict, InventoryEntry, context)

    model.repo.commit()

    return table_dictize(obj, context)
Exemplo n.º 3
0
def group_dict_save(group_dict, context):
    import uuid 
    
    model = context["model"]
    session = context["session"]
    group = context.get("group")
    allow_partial_update = context.get("allow_partial_update", False)

    Group = model.Group
    if group:
        group_dict["id"] = group.id 

    group = table_dict_save(group_dict, Group, context)
    if not group.id:
        group.id = str(uuid.uuid4())
        
    context['group'] = group

    group_member_save(context, group_dict, 'packages')
    group_member_save(context, group_dict, 'users')
    group_member_save(context, group_dict, 'groups')
    group_member_save(context, group_dict, 'tags')

    extras = group_extras_save(group_dict.get("extras", {}), context)
    if extras or not allow_partial_update:
        old_extras = set(group.extras.keys())
        new_extras = set(extras.keys())
        for key in old_extras - new_extras:
            del group.extras[key]
        for key in new_extras:
            group.extras[key] = extras[key] 


    return group
Exemplo n.º 4
0
def relationship_list_save(relationship_dicts, package, attr, context):

    allow_partial_update = context.get("allow_partial_update", False)
    if relationship_dicts is None and allow_partial_update:
        return

    model = context["model"]
    session = context["session"]
    pending = context.get('pending')

    relationship_list = getattr(package, attr)
    old_list = relationship_list[:]

    relationships = []
    for relationship_dict in relationship_dicts or []:
        obj = d.table_dict_save(relationship_dict,
                              model.PackageRelationship, context)
        relationships.append(obj)

    relationship_list[:] = relationships

    for relationship in set(old_list) - set(relationship_list):
        if pending and relationship.state <> 'deleted':
            relationship.state = 'pending-deleted'
        else:
            relationship.state = 'deleted'
        relationship_list.append(relationship)
Exemplo n.º 5
0
def tag_dict_save(tag_dict, context):
    model = context["model"]
    tag = context.get("tag")
    if tag:
        tag_dict["id"] = tag.id
    tag = d.table_dict_save(tag_dict, model.Tag, context)
    return tag
Exemplo n.º 6
0
def tag_dict_save(tag_dict, context):
    model = context['model']
    tag = context.get('tag')
    if tag:
        tag_dict['id'] = tag.id
    tag = d.table_dict_save(tag_dict, model.Tag, context)
    return tag
Exemplo n.º 7
0
def package_dict_save(pkg_dict, context):
    model = context["model"]
    package = context.get("package")
    allow_partial_update = context.get("allow_partial_update", False)
    if package:
        pkg_dict["id"] = package.id
    Package = model.Package

    if 'metadata_created' in pkg_dict:
        del pkg_dict['metadata_created']
    if 'metadata_modified' in pkg_dict:
        del pkg_dict['metadata_modified']

    pkg = d.table_dict_save(pkg_dict, Package, context)

    if not pkg.id:
        pkg.id = str(uuid.uuid4())

    package_resource_list_save(pkg_dict.get("resources"), pkg, context)
    package_tag_list_save(pkg_dict.get("tags"), pkg, context)
    package_membership_list_save(pkg_dict.get("groups"), pkg, context)

    # relationships are not considered 'part' of the package, so only
    # process this if the key is provided
    if 'relationships_as_subject' in pkg_dict:
        subjects = pkg_dict.get('relationships_as_subject')
        relationship_list_save(subjects, pkg, 'relationships_as_subject', context)
    if 'relationships_as_object' in pkg_dict:
        objects = pkg_dict.get('relationships_as_object')
        relationship_list_save(objects, pkg, 'relationships_as_object', context)

    extras = package_extras_save(pkg_dict.get("extras"), pkg, context)

    return pkg
Exemplo n.º 8
0
def package_tag_list_save(tag_dicts, package, context):
    
    allow_partial_update = context.get("allow_partial_update", False)
    if not tag_dicts and allow_partial_update:
        return

    model = context["model"]
    session = context["session"]
    pending = context.get('pending')

    tag_package_tag = dict((package_tag.tag, package_tag) 
                            for package_tag in
                            package.package_tag_all)

    tags = set()
    for tag_dict in tag_dicts:
        obj = table_dict_save(tag_dict, model.Tag, context)
        tags.add(obj)

    for tag in set(tag_package_tag.keys()) - tags:
        package_tag = tag_package_tag[tag]
        if pending and package_tag.state <> 'deleted':
            package_tag.state = 'pending-deleted'
        else:
            package_tag.state = 'deleted'

    for tag in tags - set(tag_package_tag.keys()):
        state = 'pending' if pending else 'active'
        package_tag_obj = model.PackageTag(package, tag, state)
        session.add(package_tag_obj)
        tag_package_tag[tag] = package_tag_obj

    package.package_tag_all[:] = tag_package_tag.values()
Exemplo n.º 9
0
def user_extra_save(user_dict, context):
    '''
    Save user profile extra information to database.
    Modified from ckan/lib/dictization/model_save.py:445 (user_dict_save).
    @param user_dict: dict containing user and extra information
    @param context:
    @return: list of saved model objects
    '''
    user = context.get('user_obj')
    user_extras = []

    UserExtra = kmodel.UserExtra
    if user:
        user_dict['id'] = user.id
        for field in EXTRAS:
            if user_dict.has_key(field):
                extra_row = {}
                extra_row['key'] = field
                extra_row['value'] = user_dict[field]
                user_extra = kmodel.UserExtra.by_userid_key(user.id, field)
                if user_extra:
                    extra_row['id'] = user_extra.id
                user_extras.append(
                    dictization.table_dict_save(extra_row, UserExtra, context))

    return user_extras
Exemplo n.º 10
0
def group_dict_save(group_dict, context, prevent_packages_update=False):
    from ckan.lib.search import rebuild

    model = context["model"]
    session = context["session"]
    group = context.get("group")
    allow_partial_update = context.get("allow_partial_update", False)

    Group = model.Group
    if group:
        group_dict["id"] = group.id

    group = d.table_dict_save(group_dict, Group, context)
    if not group.id:
        group.id = str(uuid.uuid4())

    context['group'] = group

    # Under the new org rules we do not want to be able to update datasets
    # via group edit so we need a way to prevent this.  It may be more
    # sensible in future to send a list of allowed/disallowed updates for
    # groups, users, tabs etc.
    if not prevent_packages_update:
        pkgs_edited = group_member_save(context, group_dict, 'packages')
    else:
        pkgs_edited = {
            'added': [],
            'removed': []
        }
    group_users_changed = group_member_save(context, group_dict, 'users')
    group_groups_changed = group_member_save(context, group_dict, 'groups')
    group_tags_changed = group_member_save(context, group_dict, 'tags')
    log.debug('Group save membership changes - Packages: %r  Users: %r  '
            'Groups: %r  Tags: %r', pkgs_edited, group_users_changed,
            group_groups_changed, group_tags_changed)

    extras = group_dict.get("extras", [])
    new_extras = {i['key'] for i in extras}
    if extras:
        old_extras = group.extras
        for key in set(old_extras) - new_extras:
            del group.extras[key]
        for x in extras:
            if 'deleted' in x and x['key'] in old_extras:
                del group.extras[x['key']]
                continue
            group.extras[x['key']] = x['value']

    # We will get a list of packages that we have either added or
    # removed from the group, and trigger a re-index.
    package_ids = pkgs_edited['removed']
    package_ids.extend( pkgs_edited['added'] )
    if package_ids:
        session.commit()
        [rebuild(package_id) for package_id in package_ids]

    return group
Exemplo n.º 11
0
def task_status_dict_save(task_status_dict, context):
    model = context["model"]
    task_status = context.get("task_status")
    allow_partial_update = context.get("allow_partial_update", False)
    if task_status:
        task_status_dict["id"] = task_status.id

    task_status = d.table_dict_save(task_status_dict, model.TaskStatus, context)
    return task_status
Exemplo n.º 12
0
    def test_07_table_simple_save(self):

        context = {"model": model,
                 "session": model.Session}

        anna1 = model.Session.query(model.Package).filter_by(name='annakarenina').one()

        anna_dictized = self.remove_changable_columns(table_dictize(anna1, context))

        anna_dictized["name"] = 'annakarenina2'

        model.repo.new_revision()
        table_dict_save(anna_dictized, model.Package, context)
        model.Session.commit()

        pkg = model.Session.query(model.Package).filter_by(name='annakarenina2').one()

        assert self.remove_changable_columns(table_dictize(pkg, context)) == anna_dictized, self.remove_changable_columns(table_dictize(pkg, context))
Exemplo n.º 13
0
def group_dict_save(group_dict, context, prevent_packages_update=False):
    from ckan.lib.search import rebuild

    model = context["model"]
    session = context["session"]
    group = context.get("group")
    allow_partial_update = context.get("allow_partial_update", False)

    Group = model.Group
    if group:
        group_dict["id"] = group.id

    group = d.table_dict_save(group_dict, Group, context)
    if not group.id:
        group.id = str(uuid.uuid4())

    context['group'] = group

    # Under the new org rules we do not want to be able to update datasets
    # via group edit so we need a way to prevent this.  It may be more
    # sensible in future to send a list of allowed/disallowed updates for
    # groups, users, tabs etc.
    if not prevent_packages_update:
        pkgs_edited = group_member_save(context, group_dict, 'packages')
    else:
        pkgs_edited = {
            'added': [],
            'removed': []
        }
    group_users_changed = group_member_save(context, group_dict, 'users')
    group_groups_changed = group_member_save(context, group_dict, 'groups')
    group_tags_changed = group_member_save(context, group_dict, 'tags')
    log.debug('Group save membership changes - Packages: %r  Users: %r  '
            'Groups: %r  Tags: %r', pkgs_edited, group_users_changed,
            group_groups_changed, group_tags_changed)

    extras = group_dict.get("extras", [])
    new_extras = {i['key'] for i in extras}
    if extras:
        old_extras = group.extras
        for key in set(old_extras) - new_extras:
            del group.extras[key]
        for x in extras:
            if 'deleted' in x and x['key'] in old_extras:
                del group.extras[x['key']]
                continue
            group.extras[x['key']] = x['value']

    # We will get a list of packages that we have either added or
    # removed from the group, and trigger a re-index.
    package_ids = pkgs_edited['removed']
    package_ids.extend( pkgs_edited['added'] )
    if package_ids:
        session.commit()
        map( rebuild, package_ids )

    return group
Exemplo n.º 14
0
def api_token_save(data_dict: dict[str, Any],
                   context: Context) -> 'model.ApiToken':
    model = context[u"model"]
    user = model.User.get(data_dict['user'])
    assert user
    return d.table_dict_save({
        u"user_id": user.id,
        u"name": data_dict[u"name"]
    }, model.ApiToken, context)
Exemplo n.º 15
0
    def test_table_simple_save(self):
        CreateTestData.create()
        context = {"model": model, "session": model.Session}
        anna1 = model.Package.get("annakarenina")

        anna_dictized = self.remove_changable_columns(
            table_dictize(anna1, context)
        )

        anna_dictized["name"] = "annakarenina2"

        table_dict_save(anna_dictized, model.Package, context)
        model.Session.commit()
        pkg = model.Package.get("annakarenina2")
        assert (
            self.remove_changable_columns(table_dictize(pkg, context))
            == anna_dictized
        ), self.remove_changable_columns(table_dictize(pkg, context))
Exemplo n.º 16
0
def task_status_dict_save(task_status_dict, context):
    model = context["model"]
    task_status = context.get("task_status")
    allow_partial_update = context.get("allow_partial_update", False)
    if task_status:
        task_status_dict["id"] = task_status.id

    task_status = d.table_dict_save(task_status_dict, model.TaskStatus, context)
    return task_status
Exemplo n.º 17
0
def group_dict_save(group_dict, context):
    from ckan.lib.search import rebuild

    model = context["model"]
    session = context["session"]
    group = context.get("group")
    allow_partial_update = context.get("allow_partial_update", False)
    prevent_packages_update = context.get("prevent_packages_update", False)

    Group = model.Group
    if group:
        group_dict["id"] = group.id

    group = d.table_dict_save(group_dict, Group, context)
    if not group.id:
        group.id = str(uuid.uuid4())

    context["group"] = group

    # Under the new org rules we do not want to be able to update datasets
    # via group edit so we need a way to prevent this.  It may be more
    # sensible in future to send a list of allowed/disallowed updates for
    # groups, users, tabs etc.
    if not prevent_packages_update:
        pkgs_edited = group_member_save(context, group_dict, "packages")
    else:
        pkgs_edited = {"added": [], "removed": []}
    group_users_changed = group_member_save(context, group_dict, "users")
    group_groups_changed = group_member_save(context, group_dict, "groups")
    group_tags_changed = group_member_save(context, group_dict, "tags")
    log.debug(
        "Group save membership changes - Packages: %r  Users: %r  " "Groups: %r  Tags: %r",
        pkgs_edited,
        group_users_changed,
        group_groups_changed,
        group_tags_changed,
    )

    # We will get a list of packages that we have either added or
    # removed from the group, and trigger a re-index.
    package_ids = pkgs_edited["removed"]
    package_ids.extend(pkgs_edited["added"])
    if package_ids:
        session.commit()
        map(rebuild, package_ids)

    extras = group_extras_save(group_dict.get("extras", {}), context)
    if extras or not allow_partial_update:
        old_extras = set(group.extras.keys())
        new_extras = set(extras.keys())
        for key in old_extras - new_extras:
            del group.extras[key]
        for key in new_extras:
            group.extras[key] = extras[key]

    return group
Exemplo n.º 18
0
def task_status_dict_save(task_status_dict: dict[str, Any],
                          context: Context) -> 'model.TaskStatus':
    model = context["model"]
    task_status = context.get("task_status")
    if task_status:
        task_status_dict["id"] = task_status.id

    task_status = d.table_dict_save(task_status_dict, model.TaskStatus,
                                    context)
    return task_status
Exemplo n.º 19
0
def resource_view_dict_save(data_dict, context):
    model = context['model']
    resource_view = context.get('resource_view')
    if resource_view:
        data_dict['id'] = resource_view.id
    config = {}
    for key, value in data_dict.iteritems():
        if key not in model.ResourceView.get_columns():
            config[key] = value
    data_dict['config'] = config

    return d.table_dict_save(data_dict, model.ResourceView, context)
Exemplo n.º 20
0
    def test_07_table_simple_save(self):

        context = {"model": model, "session": model.Session}

        anna1 = (model.Session.query(
            model.Package).filter_by(name="annakarenina").one())

        anna_dictized = self.remove_changable_columns(
            table_dictize(anna1, context))

        anna_dictized["name"] = "annakarenina2"

        table_dict_save(anna_dictized, model.Package, context)
        model.Session.commit()

        pkg = (model.Session.query(
            model.Package).filter_by(name="annakarenina2").one())

        assert (self.remove_changable_columns(table_dictize(
            pkg, context)) == anna_dictized), self.remove_changable_columns(
                table_dictize(pkg, context))
Exemplo n.º 21
0
    def test_package_tag_list_save_duplicates(self):
        name = u"testpkg19"
        context = {"model": model, "session": model.Session}
        pkg_dict = {"name": name}

        package = table_dict_save(pkg_dict, model.Package, context)

        tag_dicts = [{"name": "tag1"}, {"name": "tag1"}]  # duplicate
        package_tag_list_save(tag_dicts, package, context)
        model.repo.commit_and_remove()

        pkg = model.Package.by_name(name)
        assert set([tag.name for tag in pkg.get_tags()]) == set(("tag1", ))
Exemplo n.º 22
0
    def test_07_table_simple_save(self):

        context = {"model": model, "session": model.Session}

        anna1 = model.Session.query(
            model.Package).filter_by(name='annakarenina').one()

        anna_dictized = self.remove_changable_columns(
            table_dictize(anna1, context))

        anna_dictized["name"] = 'annakarenina2'

        model.repo.new_revision()
        table_dict_save(anna_dictized, model.Package, context)
        model.Session.commit()

        pkg = model.Session.query(
            model.Package).filter_by(name='annakarenina2').one()

        assert self.remove_changable_columns(table_dictize(
            pkg, context)) == anna_dictized, self.remove_changable_columns(
                table_dictize(pkg, context))
Exemplo n.º 23
0
def resource_view_dict_save(data_dict, context):
    model = context['model']
    resource_view = context.get('resource_view')
    if resource_view:
        data_dict['id'] = resource_view.id
    config = {}
    for key, value in data_dict.iteritems():
        if key not in model.ResourceView.get_columns():
            config[key]  = value
    data_dict['config'] = config


    return d.table_dict_save(data_dict, model.ResourceView, context)
Exemplo n.º 24
0
    def test_18_package_tag_list_save(self):
        name = u'testpkg18'
        context = {'model': model, 'session': model.Session}
        pkg_dict = {'name': name}

        package = table_dict_save(pkg_dict, model.Package, context)

        tag_dicts = [{'name': 'tag1'}, {'name': 'tag2'}]
        package_tag_list_save(tag_dicts, package, context)
        model.repo.commit_and_remove()

        pkg = model.Package.by_name(name)
        assert_equal(set([tag.name for tag in pkg.get_tags()]),
                     set(('tag1', 'tag2')))
Exemplo n.º 25
0
def package_tag_list_save(tag_dicts, package, context):
    
    allow_partial_update = context.get("allow_partial_update", False)
    if not tag_dicts and allow_partial_update:
        return

    model = context["model"]
    session = context["session"]
    pending = context.get('pending')

    tag_package_tag = dict((package_tag.tag, package_tag) 
                            for package_tag in
                            package.package_tag_all)
    
    tag_package_tag_inactive = dict(
        [ (tag,pt) for tag,pt in tag_package_tag.items() if
            pt.state in ['deleted', 'pending-deleted'] ]
        )

    tag_names = set()
    tags = set()
    for tag_dict in tag_dicts:
        if tag_dict.get('name') not in tag_names:
            tag_obj = table_dict_save(tag_dict, model.Tag, context)
            tags.add(tag_obj)
            tag_names.add(tag_obj.name)

    # 3 cases
    # case 1: currently active but not in new list
    for tag in set(tag_package_tag.keys()) - tags:
        package_tag = tag_package_tag[tag]
        if pending and package_tag.state != 'deleted':
            package_tag.state = 'pending-deleted'
        else:
            package_tag.state = 'deleted'

    # in new list but never used before
    for tag in tags - set(tag_package_tag.keys()):
        state = 'pending' if pending else 'active'
        package_tag_obj = model.PackageTag(package, tag, state)
        session.add(package_tag_obj)
        tag_package_tag[tag] = package_tag_obj

    # in new list and already used but in deleted state
    for tag in tags.intersection(set(tag_package_tag_inactive.keys())):
        state = 'pending' if pending else 'active'
        package_tag = tag_package_tag[tag]
        package_tag.state = state

    package.package_tag_all[:] = tag_package_tag.values()
Exemplo n.º 26
0
    def test_19_package_tag_list_save_duplicates(self):
        name = u"testpkg19"
        context = {"model": model, "session": model.Session}
        pkg_dict = {"name": name}

        rev = model.repo.new_revision()
        package = table_dict_save(pkg_dict, model.Package, context)

        tag_dicts = [{"name": "tag1"}, {"name": "tag1"}]  # duplicate
        package_tag_list_save(tag_dicts, package, context)
        model.repo.commit_and_remove()

        pkg = model.Package.by_name(name)
        assert_equal(set([tag.name for tag in pkg.get_tags()]), set(("tag1",)))
Exemplo n.º 27
0
    def test_19_package_tag_list_save_duplicates(self):
        name = u'testpkg19'
        context = {'model': model, 'session': model.Session}
        pkg_dict = {'name': name}

        rev = model.repo.new_revision()
        package = table_dict_save(pkg_dict, model.Package, context)

        tag_dicts = [{'name': 'tag1'}, {'name': 'tag1'}]  # duplicate
        package_tag_list_save(tag_dicts, package, context)
        model.repo.commit_and_remove()

        pkg = model.Package.by_name(name)
        assert_equal(set([tag.name for tag in pkg.tags]), set(('tag1', )))
Exemplo n.º 28
0
def package_tag_list_save(tag_dicts, package, context):
    
    allow_partial_update = context.get("allow_partial_update", False)
    if not tag_dicts and allow_partial_update:
        return

    model = context["model"]
    session = context["session"]
    pending = context.get('pending')

    tag_package_tag = dict((package_tag.tag, package_tag) 
                            for package_tag in
                            package.package_tag_all)
    
    tag_package_tag_inactive = dict(
        [ (tag,pt) for tag,pt in tag_package_tag.items() if
            pt.state in ['deleted', 'pending-deleted'] ]
        )

    tag_names = set()
    tags = set()
    for tag_dict in tag_dicts:
        if tag_dict.get('name') not in tag_names:
            tag_obj = table_dict_save(tag_dict, model.Tag, context)
            tags.add(tag_obj)
            tag_names.add(tag_obj.name)

    # 3 cases
    # case 1: currently active but not in new list
    for tag in set(tag_package_tag.keys()) - tags:
        package_tag = tag_package_tag[tag]
        if pending and package_tag.state != 'deleted':
            package_tag.state = 'pending-deleted'
        else:
            package_tag.state = 'deleted'

    # in new list but never used before
    for tag in tags - set(tag_package_tag.keys()):
        state = 'pending' if pending else 'active'
        package_tag_obj = model.PackageTag(package, tag, state)
        session.add(package_tag_obj)
        tag_package_tag[tag] = package_tag_obj

    # in new list and already used but in deleted state
    for tag in tags.intersection(set(tag_package_tag_inactive.keys())):
        state = 'pending' if pending else 'active'
        package_tag = tag_package_tag[tag]
        package_tag.state = state

    package.package_tag_all[:] = tag_package_tag.values()
Exemplo n.º 29
0
    def test_19_package_tag_list_save_duplicates(self):
        name = u'testpkg19'
        context = {'model': model,
                   'session': model.Session}
        pkg_dict = {'name': name}

        rev = model.repo.new_revision()
        package = table_dict_save(pkg_dict, model.Package, context)

        tag_dicts = [{'name': 'tag1'}, {'name': 'tag1'}] # duplicate
        package_tag_list_save(tag_dicts, package, context)
        model.repo.commit_and_remove()

        pkg = model.Package.by_name(name)
        assert_equal(set([tag.name for tag in pkg.get_tags()]), set(('tag1',)))
Exemplo n.º 30
0
def user_dict_save(user_dict, context):

    model = context['model']
    session = context['session']
    user = context.get('user_obj')

    User = model.User
    if user:
        user_dict['id'] = user.id

    if 'password' in user_dict and not len(user_dict['password']):
        del user_dict['password']

    user = d.table_dict_save(user_dict, User, context)

    return user
Exemplo n.º 31
0
def user_dict_save(user_dict, context):

    model = context['model']
    session = context['session']
    user = context.get('user_obj')

    User = model.User
    if user:
        user_dict['id'] = user.id

    if 'password' in user_dict and not len(user_dict['password']):
        del user_dict['password']

    user = d.table_dict_save(user_dict, User, context)

    return user
Exemplo n.º 32
0
def user_dict_save(user_dict, context):

    model = context["model"]
    session = context["session"]
    user = context.get("user_obj")

    User = model.User
    if user:
        user_dict["id"] = user.id

    if "password" in user_dict and not len(user_dict["password"]):
        del user_dict["password"]

    user = d.table_dict_save(user_dict, User, context)

    return user
Exemplo n.º 33
0
def package_tag_list_save(tag_dicts, package, context):
    allow_partial_update = context.get("allow_partial_update", False)
    if not tag_dicts and allow_partial_update:
        return

    model = context["model"]
    session = context["session"]
    pending = context.get("pending")

    tag_package_tag = dict((package_tag.tag, package_tag) for package_tag in package.package_tag_all)

    tag_package_tag_inactive = dict(
        [(tag, pt) for tag, pt in tag_package_tag.items() if pt.state in ["deleted", "pending-deleted"]]
    )

    tag_name_vocab = set()
    tags = set()
    for tag_dict in tag_dicts:
        if (tag_dict.get("name"), tag_dict.get("vocabulary_id")) not in tag_name_vocab:
            tag_obj = d.table_dict_save(tag_dict, model.Tag, context)
            tags.add(tag_obj)
            tag_name_vocab.add((tag_obj.name, tag_obj.vocabulary_id))

    # 3 cases
    # case 1: currently active but not in new list
    for tag in set(tag_package_tag.keys()) - tags:
        package_tag = tag_package_tag[tag]
        if pending and package_tag.state != "deleted":
            package_tag.state = "pending-deleted"
        else:
            package_tag.state = "deleted"

    # case 2: in new list but never used before
    for tag in tags - set(tag_package_tag.keys()):
        state = "pending" if pending else "active"
        package_tag_obj = model.PackageTag(package, tag, state)
        session.add(package_tag_obj)
        tag_package_tag[tag] = package_tag_obj

    # case 3: in new list and already used but in deleted state
    for tag in tags.intersection(set(tag_package_tag_inactive.keys())):
        state = "pending" if pending else "active"
        package_tag = tag_package_tag[tag]
        package_tag.state = state

    package.package_tag_all[:] = tag_package_tag.values()
Exemplo n.º 34
0
def package_tag_list_save(tag_dicts: Optional[list[dict[str, Any]]],
                          package: 'model.Package', context: Context) -> None:
    allow_partial_update = context.get("allow_partial_update", False)
    if tag_dicts is None and allow_partial_update:
        return

    model = context["model"]
    session = context["session"]

    tag_package_tag = dict(
        (package_tag.tag, package_tag) for package_tag in package.package_tags)

    tag_package_tag_inactive = {
        tag: pt
        for tag, pt in tag_package_tag.items() if pt.state in ['deleted']
    }

    tag_name_vocab: set[tuple[str, str]] = set()
    tags: set[model.Tag] = set()
    for tag_dict in tag_dicts or []:
        name_vocab = (tag_dict.get('name'), tag_dict.get('vocabulary_id'))
        if name_vocab not in tag_name_vocab:
            tag_obj = d.table_dict_save(tag_dict, model.Tag, context)
            tags.add(tag_obj)
            tag_name_vocab.add((tag_obj.name, tag_obj.vocabulary_id))

    # 3 cases
    # case 1: currently active but not in new list
    for tag in set(tag_package_tag.keys()) - tags:
        package_tag = tag_package_tag[tag]
        package_tag.state = 'deleted'

    # case 2: in new list but never used before
    for tag in tags - set(tag_package_tag.keys()):
        state = 'active'
        package_tag_obj = model.PackageTag(package, tag, state)
        session.add(package_tag_obj)
        tag_package_tag[tag] = package_tag_obj

    # case 3: in new list and already used but in deleted state
    for tag in tags.intersection(set(tag_package_tag_inactive.keys())):
        state = 'active'
        package_tag = tag_package_tag[tag]
        package_tag.state = state

    package.package_tags[:] = tag_package_tag.values()
Exemplo n.º 35
0
def _basket_element_add(context, model, package_id, basket):
    pkg = tk.get_action('package_show')(context, {'id': package_id})

    if pkg['id'] not in basket.as_dict()['packages']:
        basket_association = d.table_dict_save(
            {
                'basket_id': basket.id,
                'package_id': pkg['id']
            }, BasketAssociation, context)
        basket_association = basket_association.as_dict()
    else:
        return None

    if not context.get('defer_commit'):
        model.repo.commit()

    return basket_association
Exemplo n.º 36
0
def group_dict_save(group_dict, context):
    from ckan.lib.search import rebuild

    model = context["model"]
    session = context["session"]
    group = context.get("group")
    allow_partial_update = context.get("allow_partial_update", False)

    Group = model.Group
    if group:
        group_dict["id"] = group.id

    group = d.table_dict_save(group_dict, Group, context)
    if not group.id:
        group.id = str(uuid.uuid4())

    context['group'] = group

    pkgs_edited = group_member_save(context, group_dict, 'packages')
    group_users_changed = group_member_save(context, group_dict, 'users')
    group_groups_changed = group_member_save(context, group_dict, 'groups')
    group_tags_changed = group_member_save(context, group_dict, 'tags')
    log.debug(
        'Group save membership changes - Packages: %r  Users: %r  '
        'Groups: %r  Tags: %r', pkgs_edited, group_users_changed,
        group_groups_changed, group_tags_changed)

    # We will get a list of packages that we have either added or
    # removed from the group, and trigger a re-index.
    package_ids = pkgs_edited['removed']
    package_ids.extend(pkgs_edited['added'])
    if package_ids:
        session.commit()
        map(rebuild, package_ids)

    extras = group_extras_save(group_dict.get("extras", {}), context)
    if extras or not allow_partial_update:
        old_extras = set(group.extras.keys())
        new_extras = set(extras.keys())
        for key in old_extras - new_extras:
            del group.extras[key]
        for key in new_extras:
            group.extras[key] = extras[key]

    return group
Exemplo n.º 37
0
def package_tag_list_save(tag_dicts, package, context):
    allow_partial_update = context.get("allow_partial_update", False)
    if tag_dicts is None and allow_partial_update:
        return

    model = context["model"]
    session = context["session"]

    tag_package_tag = dict((package_tag.tag, package_tag)
                            for package_tag in
                            package.package_tag_all)

    tag_package_tag_inactive = dict(
        [ (tag,pt) for tag,pt in tag_package_tag.items() if
            pt.state in ['deleted'] ]
        )

    tag_name_vocab = set()
    tags = set()
    for tag_dict in tag_dicts or []:
        if (tag_dict.get('name'), tag_dict.get('vocabulary_id')) not in tag_name_vocab:
            tag_obj = d.table_dict_save(tag_dict, model.Tag, context)
            tags.add(tag_obj)
            tag_name_vocab.add((tag_obj.name, tag_obj.vocabulary_id))

    # 3 cases
    # case 1: currently active but not in new list
    for tag in set(tag_package_tag.keys()) - tags:
        package_tag = tag_package_tag[tag]
        package_tag.state = 'deleted'

    # case 2: in new list but never used before
    for tag in tags - set(tag_package_tag.keys()):
        state = 'active'
        package_tag_obj = model.PackageTag(package, tag, state)
        session.add(package_tag_obj)
        tag_package_tag[tag] = package_tag_obj

    # case 3: in new list and already used but in deleted state
    for tag in tags.intersection(set(tag_package_tag_inactive.keys())):
        state = 'active'
        package_tag = tag_package_tag[tag]
        package_tag.state = state

    package.package_tag_all[:] = tag_package_tag.values()
Exemplo n.º 38
0
def group_dict_save(group_dict, context):
    from ckan.lib.search import rebuild

    model = context["model"]
    session = context["session"]
    group = context.get("group")
    allow_partial_update = context.get("allow_partial_update", False)

    Group = model.Group
    if group:
        group_dict["id"] = group.id

    group = d.table_dict_save(group_dict, Group, context)
    if not group.id:
        group.id = str(uuid.uuid4())

    context['group'] = group

    pkgs_edited = group_member_save(context, group_dict, 'packages')
    group_users_changed = group_member_save(context, group_dict, 'users')
    group_groups_changed = group_member_save(context, group_dict, 'groups')
    group_tags_changed = group_member_save(context, group_dict, 'tags')
    log.debug('Group save membership changes - Packages: %r  Users: %r  '
            'Groups: %r  Tags: %r', pkgs_edited, group_users_changed,
            group_groups_changed, group_tags_changed)

    # We will get a list of packages that we have either added or
    # removed from the group, and trigger a re-index.
    package_ids = pkgs_edited['removed']
    package_ids.extend( pkgs_edited['added'] )
    if package_ids:
        session.commit()
        map( rebuild, package_ids )

    extras = group_extras_save(group_dict.get("extras", {}), context)
    if extras or not allow_partial_update:
        old_extras = set(group.extras.keys())
        new_extras = set(extras.keys())
        for key in old_extras - new_extras:
            del group.extras[key]
        for key in new_extras:
            group.extras[key] = extras[key]

    return group
Exemplo n.º 39
0
def inventory_entry_update(context, data_dict):
    # TODO @palcu: DRY this w/ inventory_entry_create
    model = context['model']
    schema = context['schema']
    session = context['session']

    organization = model.Group.get(context['organization_name'])
    data_dict['group_id'] = organization.id
    data_dict['is_recurring'] = (data_dict['recurring_interval'] != '0')

    data, errors = navl_validate(data_dict, schema, context)

    if errors:
        session.rollback()
        raise ValidationError(errors)

    obj = table_dict_save(data_dict, InventoryEntry, context)
    model.repo.commit()

    return table_dictize(obj, context)
Exemplo n.º 40
0
def inventory_entry_update(context, data_dict):
    # TODO @palcu: DRY this w/ inventory_entry_create
    model = context['model']
    schema = context['schema']
    session = context['session']

    organization = model.Group.get(context['organization_name'])
    data_dict['group_id'] = organization.id
    data_dict['is_recurring'] = (data_dict['recurring_interval'] != '0')

    data, errors = navl_validate(data_dict, schema, context)

    if errors:
        session.rollback()
        raise ValidationError(errors)

    obj = table_dict_save(data_dict, InventoryEntry, context)
    model.repo.commit()

    return table_dictize(obj, context)
Exemplo n.º 41
0
def inventory_entry_bulk_create(context, data_dict):
    model = context['model']
    schema = context['schema']
    session = context['session']

    organization = model.Group.get(context['organization_name'])
    inventory_entry_dict = {'group_id': organization.id}

    if not data_dict['field-name-input-0']:
        raise ValidationError(
            {'error': [_('Please add at least one inventory entry.')]})

    for inventory_entry_id in range(10):
        inventory_entry_name = data_dict['field-name-input-' +
                                         str(inventory_entry_id)]
        if not inventory_entry_name:
            break

        inventory_entry_dict['title'] = inventory_entry_name
        inventory_entry_dict['recurring_interval'] = data_dict[
            'field-recurring-input-' + str(inventory_entry_id)]
        inventory_entry_dict['is_recurring'] = (
            inventory_entry_dict['recurring_interval'] != '0')

        data, errors = navl_validate(inventory_entry_dict, schema, context)

        if errors:
            session.rollback()
            # TODO @palcu: i18n
            raise ValidationError({
                'error': [
                    _('Verificati intrarea cu numarul {0}.'.format(
                        inventory_entry_id + 1))
                ]
            })

        obj = table_dict_save(inventory_entry_dict, InventoryEntry, context)

    model.repo.commit()

    return table_dictize(obj, context)
Exemplo n.º 42
0
def group_dict_save(group_dict, context):
    from ckan.lib.search import rebuild

    model = context["model"]
    session = context["session"]
    group = context.get("group")
    allow_partial_update = context.get("allow_partial_update", False)

    Group = model.Group
    if group:
        group_dict["id"] = group.id

    group = d.table_dict_save(group_dict, Group, context)
    if not group.id:
        group.id = str(uuid.uuid4())

    context["group"] = group

    pkgs_edited = group_member_save(context, group_dict, "packages")
    group_member_save(context, group_dict, "users")
    group_member_save(context, group_dict, "groups")
    group_member_save(context, group_dict, "tags")

    # We will get a list of packages that we have either added or
    # removed from the group, and trigger a re-index.
    package_ids = pkgs_edited["removed"]
    package_ids.extend(pkgs_edited["added"])
    if package_ids:
        session.commit()
        map(rebuild, package_ids)

    extras = group_extras_save(group_dict.get("extras", {}), context)
    if extras or not allow_partial_update:
        old_extras = set(group.extras.keys())
        new_extras = set(extras.keys())
        for key in old_extras - new_extras:
            del group.extras[key]
        for key in new_extras:
            group.extras[key] = extras[key]

    return group
Exemplo n.º 43
0
def user_dict_save(user_dict, context):

    model = context['model']
    session = context['session']
    user = context.get('user_obj')

    User = model.User
    if user:
        user_dict['id'] = user.id

    if 'password' in user_dict and not len(user_dict['password']):
        del user_dict['password']

    user = d.table_dict_save(
        user_dict,
        User,
        context,
        extra_attrs=['_password'],  # for setting password_hash directly
    )

    return user
Exemplo n.º 44
0
def group_dict_save(group_dict, context):

    model = context["model"]
    session = context["session"]
    group = context.get("group")
    allow_partial_update = context.get("allow_partial_update", False)
    
    Group = model.Group
    Package = model.Package
    if group:
        group_dict["id"] = group.id 

    group = table_dict_save(group_dict, Group, context)
    extras = group_extras_save(group_dict.get("extras", {}), context)
    if extras or not allow_partial_update:
        old_extras = set(group.extras.keys())
        new_extras = set(extras.keys())
        for key in old_extras - new_extras:
            del group.extras[key]
        for key in new_extras:
            group.extras[key] = extras[key] 

    package_dicts = group_dict.get("packages", [])

    packages = []

    for package in package_dicts:
        pkg = None
        id = package.get("id")
        if id:
            pkg = session.query(Package).get(id)
        if not pkg:
            pkg = session.query(Package).filter_by(name=package["name"]).first()
        if pkg:
            packages.append(pkg)

    if packages or not allow_partial_update:
        group.packages[:] = packages

    return group
Exemplo n.º 45
0
def group_dict_save(group_dict, context):

    model = context["model"]
    session = context["session"]
    group = context.get("group")
    allow_partial_update = context.get("allow_partial_update", False)
    
    Group = model.Group
    Package = model.Package
    if group:
        group_dict["id"] = group.id 

    group = table_dict_save(group_dict, Group, context)
    extras = group_extras_save(group_dict.get("extras", {}), context)
    if extras or not allow_partial_update:
        old_extras = set(group.extras.keys())
        new_extras = set(extras.keys())
        for key in old_extras - new_extras:
            del group.extras[key]
        for key in new_extras:
            group.extras[key] = extras[key] 

    package_dicts = group_dict.get("packages", [])

    packages = []

    for package in package_dicts:
        pkg = None
        id = package.get("id")
        if id:
            pkg = session.query(Package).get(id)
        if not pkg:
            pkg = session.query(Package).filter_by(name=package["name"]).first()
        if pkg and pkg not in packages:
            packages.append(pkg)

    if packages or not allow_partial_update:
        group.packages[:] = packages

    return group
Exemplo n.º 46
0
def relationship_list_save(relationship_dicts, package, attr, context):

    allow_partial_update = context.get("allow_partial_update", False)
    if relationship_dicts is None and allow_partial_update:
        return

    model = context["model"]
    session = context["session"]

    relationship_list = getattr(package, attr)
    old_list = relationship_list[:]

    relationships = []
    for relationship_dict in relationship_dicts or []:
        obj = d.table_dict_save(relationship_dict, model.PackageRelationship,
                                context)
        relationships.append(obj)

    relationship_list[:] = relationships

    for relationship in set(old_list) - set(relationship_list):
        relationship.state = 'deleted'
        relationship_list.append(relationship)
Exemplo n.º 47
0
def package_dict_save(pkg_dict, context):

    model = context["model"]
    package = context.get("package")
    allow_partial_update = context.get("allow_partial_update", False)
    if package:
        pkg_dict["id"] = package.id 
    Package = model.Package

    pkg = table_dict_save(pkg_dict, Package, context)

    package_resource_list_save(pkg_dict.get("resources", []), pkg, context)
    package_tag_list_save(pkg_dict.get("tags", []), pkg, context)
    package_group_list_save(pkg_dict.get("groups", []), pkg, context)

    subjects = pkg_dict.get('relationships_as_subject', [])
    relationship_list_save(subjects, pkg, 'relationships_as_subject', context)
    objects = pkg_dict.get('relationships_as_object', [])
    relationship_list_save(subjects, pkg, 'relationships_as_object', context)

    extras = package_extras_save(pkg_dict.get("extras", []), pkg, context)

    return pkg
Exemplo n.º 48
0
def marsavin_pages_save(context, data_dict):
    schema = context["schema"]
    model = context["model"]
    session = context["session"]
    marsavin_page_dict, errors = _validate(data=data_dict, schema=schema,
                                           context=context)
    
    if errors:
        raise ValidationError(errors)
    
    marsavin_page = d.table_dict_save(marsavin_page_dict, MarsavinPages,
                                      context)
    
    # generate the user id
    session.flush()
    
    if not context.get('defer_commit'):
        try:
            model.repo.commit()
        except Exception as e:
            log.debug(e.message)
            session.rollback()
    
    return marsavin_page
Exemplo n.º 49
0
def package_dict_save(pkg_dict, context):
    model = context["model"]
    package = context.get("package")
    allow_partial_update = context.get("allow_partial_update", False)
    if package:
        pkg_dict["id"] = package.id
    Package = model.Package

    if 'metadata_created' in pkg_dict:
        del pkg_dict['metadata_created']
    if 'metadata_modified' in pkg_dict:
        del pkg_dict['metadata_modified']

    pkg = d.table_dict_save(pkg_dict, Package, context)

    if not pkg.id:
        pkg.id = str(uuid.uuid4())

    package_resource_list_save(pkg_dict.get("resources"), pkg, context)
    package_tag_list_save(pkg_dict.get("tags"), pkg, context)
    package_membership_list_save(pkg_dict.get("groups"), pkg, context)

    # relationships are not considered 'part' of the package, so only
    # process this if the key is provided
    if 'relationships_as_subject' in pkg_dict:
        subjects = pkg_dict.get('relationships_as_subject')
        relationship_list_save(subjects, pkg, 'relationships_as_subject',
                               context)
    if 'relationships_as_object' in pkg_dict:
        objects = pkg_dict.get('relationships_as_object')
        relationship_list_save(objects, pkg, 'relationships_as_object',
                               context)

    extras = package_extras_save(pkg_dict.get("extras"), pkg, context)

    return pkg
Exemplo n.º 50
0
def basket_update(context, data_dict):
    """Update a basket

    :param id: The id of the basket
    :type id: string
    :returns:
    """
    tk.check_access('basket_owner_only', context, data_dict)
    model = context['model']
    id = _get_or_bust(data_dict, 'id')

    basket = Basket.get(id)
    context["basket"] = basket
    if basket is None:
        raise tk.ObjectNotFound('Basket was not found.')

    tk.check_access('basket_update', context, data_dict)

    basket = d.table_dict_save(data_dict, Basket, context)

    if not context.get('defer_commit'):
        model.repo.commit()

    return basket.as_dict()
Exemplo n.º 51
0
def related_dict_save(related_dict, context):
    model = context['model']
    session = context['session']

    return d.table_dict_save(related_dict, model.Related, context)
Exemplo n.º 52
0
def role_permission_dict_save(role_permission_dict, context):
    return d.table_dict_save(role_permission_dict, extmodel.RolePermission,
                             context)
Exemplo n.º 53
0
def user_role_dict_save(user_role_dict, context):
    return d.table_dict_save(user_role_dict, extmodel.UserRole, context)
Exemplo n.º 54
0
def role_dict_save(role_dict, context):
    role = context.get('role')
    if role:
        role_dict['id'] = role.id
    return d.table_dict_save(role_dict, extmodel.Role, context)
Exemplo n.º 55
0
def related_dict_save(related_dict, context):
    model = context['model']
    session = context['session']

    return d.table_dict_save(related_dict,model.Related, context)
Exemplo n.º 56
0
def reqaccess_dict_save(reqaccess_dict, context):
    reqaccess = d.table_dict_save(reqaccess_dict, AccessRequests, context)

    return reqaccess
Exemplo n.º 57
0
def related_dict_save(related_dict, context):
    model = context["model"]
    session = context["session"]

    return d.table_dict_save(related_dict, model.Related, context)
Exemplo n.º 58
0
def inventory_item_create(context, data_dict):
    model = context['model']
    obj = table_dict_save(data_dict, InventoryItem, context)
    model.repo.commit()

    return table_dictize(obj, context)