Sortable roles by weight

Thank you for your reply.

1) Don't you mean the OG role permissions are defined here? I don't see a way for a site admin to define more default roles for groups. There are the three you have defined, but no method to create more. Or am I missing something?
For example, the site I'm moving to Drupal has groups with 3 defined roles that would need to exist between "member" and "admin-member." The users should not have to define those roles and assign permissions when they create a group. As site admin, I would like to define roles and assign permissions globally that apply to all groups.

2) Perhaps. See below :-)

3) I will try to repeat this process.

4) No comprehension. See below... lol

I am a PHP programmer professionally but this is my first foray into Drupal. We have decided Drupal to be the best CMS for our project, and I'm just getting into what it can do and what is available. Groups is a big part of our system when it comes to who can access, edit, submit, etc.

So, when I'm up to snuff on the API I will be more than happy to patch, invent, and/or otherwise twist and help out where I can. :-) Some of the things I mention above are definitely needed by our system, so it will require me doing something.

Thanks again for the reply :-)

Related to what I discussed above....
Attached is my attempt to add the functionality of adding/editing/removing default roles. As mentioned above, I'm just learning Drupal, so there will probably be mistakes or things I should have done differently. Feel free to criticize and make suggestions. I used existing OG functions where possible... or at least where I found them. Not sure if it is right to do this or whether functions to retrieve/insert data should be encapsulated within the new module itself.

I added this module within the OG module directory, hoping it might become part of the project as a whole. I named it og_roles because og_default_roles is used in some current functions. Could be named something else if desired. Following the OG module example, I took much of the code from the User module and altered it according to the need.

If this seems like something you might want to add to the project, might I make a few proposals?

1) Would it be possible to add "weight" to the og_role table? When adding roles via this module or the user group interface, the roles appear out of order in the list and permissions. Of course, this would mean changing select statements to order by weight, as well as changing some forms so weight can be set. Changing the form in the og_roles to allow for weights is a simple matter.

2) Use constants to define the default "non-member", "member", and "administrator member" ids instead of defining constants to their string equivalents.

I noticed in the Drupal user module, ids for non-member and member are used, and the administrator role string can be renamed. Since I could not find code in the Drupal core comparing or setting access according to the string, I assume the only reason for Drupal core not allowing the change of "non-member" and "member" is so people do not get confused. Unless I missed something?

Being able to change these strings in OG can be done by altering code so their Ids are used instead of the strings themselves. I know this is not an easy thing to do, as the constants are used throughout the OG module, but I'm willing to help convert code. Or, perhaps provide a way to change the constants?

Anyway... I admit I'm new to this... so feel free to let her rip :-)

>Anyway, f this is your first Drupal module, then boy -- you are on the right way! ;)

Thank you, but the credit is not deserved. Most of the code is simply copied and pasted from the Drupal User module, then tweaked and tinkered with where necessary.

> Indeed this is done via code see og.api.php -- hook_og_default_roles().
I will take a look at what you described here when I have some time. Thank you for pointing it out.

I've come back to this after working on some other things. Thanks for adding the user role stuff to your module.
In order to make it "prettier" I took some time rewriting some of the dev branch so "weight" can be used with the roles. The code changes will allow a site administrator to order the roles, as well as allow a group admin to reorder them. This also gives a nicer looking table in the permissions so instead of this:

non-member | member | administrator member | scientist | lead scientist

you will get this:

non-member | member | scientist | lead scientist | administrator member

when adding new roles.

Edit: This is an after thought after already writing this post. When a group is allowed to override the default roles, so a group admin can manage a group's roles and permissions, the default roles are duplicated for that group id. Where is this code located? Probably best to use the same weights as the defaults.

The code changes I made are below, listed by file and function.

Need to add the weight column to the og_role table and update it so:
non-member defaults to 0
member weight = 1
administrator member weight = 2

'weight' => array(
  'type' => 'int',
  'size' => 'normal',
  'default' => 0,
  'description' => 'The weight of this role in listings and the user interface.',
),

og.module - Changed line 2064 and 2067 sql statements to order by weight.
I didn't notice anywhere else in the code where the order would matter. Something to look into?

if (!empty($permission)) {
    $roles = db_query("SELECT r.rid, r.name FROM {og_role} r INNER JOIN {og_role_permission} p ON r.rid = p.rid WHERE p.permission = :permission AND r.gid = :gid ORDER BY r.weight", array(':permission' => $permission, ':gid' => $gid))->fetchAllKeyed();
  }
  else {
    $roles = db_query("SELECT rid, name FROM {og_role} WHERE gid = :gid ORDER BY weight", array(':gid' => $gid))->fetchAllKeyed();
  }

og.module - Changed function og_role_save().
Added if (!isset($role->weight)) like it's used in the user module.

function og_role_save($role) {
  if ($role->name) {
    // Prevent leading and trailing spaces in role names.
    $role->name = trim($role->name);
  }
  if (!isset($role->weight)) {
    // Set a role weight to make this new role last.
    $query = db_select('og_role');
    $query->addExpression('MAX(weight)');
    $role->weight = $query->execute()->fetchField() + 1;
  }
  if (!empty($role->rid) && $role->name) {
    $status = drupal_write_record('og_role', $role, 'rid');
    module_invoke_all('og_role_update', $role);
  }
  else {
    $status = drupal_write_record('og_role', $role);
    module_invoke_all('og_role_insert', $role);
  }

  og_invalidate_cache();

  return $status;
}

og_ui.admin.inc - changed function og_ui_user_admin_roles()
Added code for the weight field and button to save weights.

function og_ui_user_admin_roles($form, $form_state, $entity_type = '', $etid = 0, $rid = 0) {
  $gid = 0;
  if ($entity_type && $group = og_get_group($entity_type, $etid)) {
    $gid = $group->gid;
  }

  $form['gid'] = array('#type' => 'value', '#value' => $gid);

  if ($rid) {
    if ($gid) {
      og_set_breadcrumb($entity_type, $etid, array(l(t('Group'), "$entity_type/$etid/group")), l(t('Roles'), "group/$entity_type/$etid/admin/people/roles"));
    }

    $group_roles = og_roles($gid);
    if (!in_array($rid, array_keys($group_roles))) {
      drupal_goto($gid ? "group/$entity_type, $etid/admin/people/roles" : 'admin/config/group/roles');
    }
    // Display the edit role form.
    $role = og_role_load($rid);
    $form['name'] = array(
      '#type' => 'textfield',
      '#title' => t('Role name'),
      '#default_value' => $role->name,
      '#size' => 30,
      '#required' => TRUE,
      '#maxlength' => 64,
      '#description' => t('The name for this role. Example: "moderator", "editorial board", "site architect".'),
    );
    $form['rid'] = array(
      '#type' => 'value',
      '#value' => $rid,
    );
    $form['weight'] = array(
      '#type' => 'value',
      '#value' => $role->weight,
    );
    $form['actions'] = array('#type' => 'actions');
    $form['actions']['submit'] = array(
      '#type' => 'submit',
      '#value' => t('Save role'),
    );
    $form['actions']['delete'] = array(
      '#type' => 'submit',
      '#value' => t('Delete role'),
    );
  }
  else {
    // No role ID.
    if ($gid) {
      og_set_breadcrumb($entity_type, $etid, array(l(t('Group'), "$entity_type/$etid/group")));
    }
    if (!$gid || !og_is_group_default_access($group->gid)) {
      $form['name'] = array(
        '#type' => 'textfield',
        '#title' => t('Name'),
        '#title_display' => 'invisible',
        '#size' => 32,
        '#maxlength' => 64,
      );
      $form['roles'] = array(
        '#tree' => TRUE,
      );
      $order = 0;
      foreach (og_roles($gid) as $rid => $name) {
        $form['roles'][$rid]['#role'] = (object) array(
          'rid' => $rid,
          'name' => $name,
          'weight' => $order,
        );
        $form['roles'][$rid]['#weight'] = $order;
        $form['roles'][$rid]['weight'] = array(
          '#type' => 'textfield',
          '#title' => t('Weight for @title', array('@title' => $name)),
          '#title_display' => 'invisible',
          '#size' => 4,
          '#default_value' => $order,
          '#attributes' => array('class' => array('role-weight')),
        );
        $order++;
      }
      $form['add'] = array(
        '#type' => 'submit',
        '#value' => t('Add role'),
        '#validate' => array('og_ui_user_admin_roles_validate'),
        '#submit' => array('og_ui_user_admin_roles_submit'),
      );

      // Attach the CSS to the form.
      $form['#attached'] = array(
        'css' => array (
          'type' => 'file',
          'data' => drupal_get_path('module', 'og_ui') . '/css/og_ui.css',
        ),
      );

      $form['actions'] = array('#type' => 'actions');
      $form['actions']['submit'] = array(
        '#type' => 'submit',
        '#value' => t('Save order'),
        '#submit' => array('og_ui_user_admin_roles_order_submit'),
      );
    }
  }

  return $form;
}

og_ui.admin.inc - changed function og_ui_user_admin_roles_submit()
Added if (!empty($form_state['values']['weight']))

function og_ui_user_admin_roles_submit($form, &$form_state) {
  $gid = $form_state['values']['gid'];
  if ($gid) {
    $group = og_load($gid);
  }
  $role = new stdClass();
  $role->gid = $gid;
  $role->name = $form_state['values']['name'];
  if (!empty($form_state['values']['rid'])) {
    $role->rid = $form_state['values']['rid'];
  }
  if (!empty($form_state['values']['weight'])) {
    $role->weight = $form_state['values']['weight'];
  }
  // Indicates if we need to save role.
  $save = FALSE;
  if ($form_state['values']['op'] == t('Save role')) {
    og_role_save($role);
    drupal_set_message(t('The role has been renamed.'));
  }
  elseif ($form_state['values']['op'] == t('Add role')) {
    og_role_save($role);
    drupal_set_message(t('The role has been added.'));
  }
  elseif ($form_state['values']['op'] == t('Delete role')) {
    og_role_delete($form_state['values']['rid']);
    drupal_set_message(t('The role has been deleted.'));
  }

  $form_state['redirect'] = $gid ? 'group/' . $group->entity_type . '/' . $group->etid . '/admin/people/roles' : 'admin/config/group/roles';
  return;
}

og_ui.admin.inc - added function og_ui_user_admin_roles_order_submit()
Based on user module.

function og_ui_user_admin_roles_order_submit($form, &$form_state) {
  foreach ($form_state['values']['roles'] as $rid => $role_values) {
    $role = $form['roles'][$rid]['#role'];
    $role->weight = $role_values['weight'];
    og_role_save($role);
  }
  drupal_set_message(t('The role settings have been updated.'));
}

og_ui.admin.inc - changed function theme_og_ui_user_admin_new_role()
Added various lines to handle the weight field and making the table rows draggable.

function theme_og_ui_user_admin_new_role($variables) {
  $form = $variables['form'];
  $header = array(t('Name'), t('Weight'), array('data' => t('Operations'), 'colspan' => 2));
  // The group entity.
  if ($gid = $form['gid']['#value']) {
    $group = og_get_group('group', $gid);
  }

  $default_access = $gid && og_is_group_default_access($gid);

  $order = 0;
  foreach (og_roles($gid) as $rid => $name) {
    $text = !$default_access ? t('edit permissions') : t('view permissions');
    $path = $gid ? 'group/' . $group->entity_type .'/' . $group->etid . '/admin/people' : 'admin/config/group';
    $permissions = l($text, $path . '/permissions/' . $rid);
    $weight = !$default_access ? drupal_render($form['roles'][$rid]['weight']) : $order;

    if (!$default_access && !in_array($name, array(OG_ANONYMOUS_ROLE, OG_AUTHENTICATED_ROLE))) {
      $rows[] = array('data' => array($name, $weight, l(t('edit role'), $path . '/roles/edit/' . $rid), $permissions), 'class' => array('draggable'));
    }
    else {
      $rows[] = array('data' => array($name, $weight, t('locked'), $permissions), 'class' => array('draggable'));
    }
    $order++;
  }
  
  $rows[] = array(array('data' => drupal_render($form['name']) . drupal_render($form['add']), 'colspan' => 4, 'class' => 'edit-name'));

  if (!$default_access) drupal_add_tabledrag('og-user-roles', 'order', 'sibling', 'role-weight');

  $output = theme('table', array('header' => $header, 'rows' => $rows, 'attributes' => array('id' => 'og-user-roles')));
  $output .= drupal_render_children($form);
  
  return $output;
}

I was simply showing you the changes I made in order to allow ordering the roles by weight. Either the default roles in the admin area, or the roles in a group admin page. I did not know how else to show you accept by putting it here.

How else should I do it?

didn't know how to do that. are there instructions some where?

Edit: Nevermind... reading about it now

Hope this is correct :-)

Edit: Forgot, but patch would require changing the db. Not sure how to represent that.
Need to add the weight column to the og_role table and update it so:
non-member defaults to 0
member weight = 1
administrator member weight = 2

Trying this again. Let me know if something is wrong.