Updates the mail server mailing lists based on the
    selections in the UserProfile model.
494782
def manage_mailists_on_userprofile_m2m_changed(
    action, instance, pk_set, sender, **kwargs
):
    
    try:
        instance.email_notifications
    except AttributeError:
        pass
    else:
        if action == "post_remove":
            update_mailing_lists_in_m2m(
                sender=sender,
                userprofile=instance,
                unsubscribe=True,
                pk_set=pk_set,
                verbose=True,
            )
        elif action == "post_add":
            update_mailing_lists_in_m2m(
                sender=sender,
                userprofile=instance,
                subscribe=True,
                pk_set=pk_set,
                verbose=True,
            )
567211
protected void update() {
        int sz = dataModel.getSize();
        int[] selected = helperList.getSelectedIndices();
        ArrayList sourceItems = new ArrayList(sz);
        ArrayList chosenItems = new ArrayList(selected.length);

        // Start with the source items filled from our data model
        for (int i = 0; i < sz; i++) {
            sourceItems.add(dataModel.getElementAt(i));
        }

        // Now move the selected items to the chosen list
        for (int i = selected.length - 1; i >= 0; i--) {
            chosenItems.add(sourceItems.remove(selected[i]));
        }

        Collections.reverse(chosenItems); // We built it backwards

        // Now install the two new lists
        sourceList.setListData(sourceItems.toArray());
        chosenList.setListData(chosenItems.toArray());
    }
604533
def UpdateUserNotifications(self, username, timestamps, state=None):
    """"""
    if not timestamps:
      return

    for n in self.notifications_by_username.get(username, []):
      if n.timestamp in timestamps:
        n.state = state
911485
def update(self, **kwargs):
        

        item = self._client['users/*/lists/*'].update(self.username, self.id, return_type='data', **kwargs)

        if not item:
            return False

        self._update(item)
        return True
30145
protected function UpdateWishlist()
    {
        $aInput = $this->global->GetUserData(TdbPkgShopWishlist::URL_PARAMETER_FILTER_DATA);
        $sWishListDescription = '';
        if (array_key_exists('description', $aInput)) {
            $sWishListDescription = $aInput['description'];
        }
        $oMsgManager = TCMSMessageManager::GetInstance();

        $oUser = TdbDataExtranetUser::GetInstance();
        if ($oUser->IsLoggedIn()) {
            $oWishlist = &$oUser->GetWishlist(true);
            $aTmp = $oWishlist->sqlData;
            $aTmp['description'] = $sWishListDescription;
            if (array_key_exists('is_public', $aInput)) {
                $aTmp['is_public'] = $aInput['is_public'];
            }

            $oWishlist->LoadFromRow($aTmp);
            $oWishlist->Save();

            $aItems = array();
            if (array_key_exists('aItem', $aInput) && is_array($aInput['aItem'])) {
                $aItems = $aInput['aItem'];
                foreach ($aItems as $sWishlistItemId => $aItemData) {
                    $oWishlistItem = TdbPkgShopWishlistArticle::GetNewInstance();
                    /** @var $oWishlistItem TdbPkgShopWishlistArticle */
                    if ($oWishlistItem->LoadFromFields(array('pkg_shop_wishlist_id' => $oWishlist->id, 'id' => $sWishlistItemId))) {
                        $atmpData = $oWishlistItem->sqlData;
                        if (array_key_exists('comment', $aItemData)) {
                            $atmpData['comment'] = $aItemData['comment'];
                        }
                        if (array_key_exists('amount', $aItemData)) {
                            $atmpData['amount'] = $aItemData['amount'];
                        }
                        $oWishlistItem->LoadFromRow($atmpData);
                        $oWishlistItem->AllowEditByAll(true);
                        $oWishlistItem->Save();
                    }
                }
            }

            $oMsgManager->AddMessage($oWishlist->GetMsgConsumerName(), 'WISHLIST-UPDATED-INFOS');
        }
    }
691553
void updateUserInfo() {

        try {
            m_user = m_context.getCms().readUser(m_user.getId());
            displayResourceInfoDirectly(Collections.singletonList(CmsAccountsApp.getPrincipalInfo(m_user)));
        } catch (CmsException e) {
            LOG.error("Error updating user info.", e);
        }
    }
440572
public void setUserMFASettingList(java.util.Collection<String> userMFASettingList) {
        if (userMFASettingList == null) {
            this.userMFASettingList = null;
            return;
        }

        this.userMFASettingList = new java.util.ArrayList<String>(userMFASettingList);
    }
708337
function onUpdateProfile() {
  var displayName = $('#display-name').val();
  var photoURL = $('#photo-url').val();
  activeUser().updateProfile({
    'displayName': displayName,
    'photoURL': photoURL
  }).then(function() {
    refreshUserData();
    alertSuccess('Profile updated!');
  }, onAuthError);
}
1192969
def add(member_address, options={})
      params = {:address => member_address}
      Mailgun.submit :post, list_member_url, params.merge(options)
    end
354056
def post_user_contact_lists_contacts(self, id, contact_list_id, **data):
        
        
        return self.post("/users/{0}/contact_lists/{0}/contacts/".format(id,contact_list_id), data=data)
1180785
def update_org_users(cls, module):
        
        try:
            cls.module_registry[module]["OrgUserModel"]._meta.get_field("user")
        except FieldDoesNotExist:
            cls.module_registry[module]["OrgUserModel"].add_to_class(
                "user",
                models.ForeignKey(
                    USER_MODEL,
                    related_name="%(app_label)s_%(class)s",
                    on_delete=models.CASCADE,
                ),
            )
        try:
            cls.module_registry[module]["OrgUserModel"]._meta.get_field("organization")
        except FieldDoesNotExist:
            cls.module_registry[module]["OrgUserModel"].add_to_class(
                "organization",
                models.ForeignKey(
                    cls.module_registry[module]["OrgModel"],
                    related_name="organization_users",
                    on_delete=models.CASCADE,
                ),
            )
1083775
private void updateListActivity(boolean setSelection) {
        activityListModel.clear();
        if (getDialogObject() != null) {
            List<String> activities = new ArrayList<String>(getDialogObject().getActivities());
            Collections.sort(activities);
            for (String activity : activities) {
                activityListModel.addElement(activity);
            }
        }
        if (!activityListModel.isEmpty() && setSelection) {
            activityList.setSelectedIndex(0);
        }
    }
727185
public function updateUser(UpdateProfileUserRequest $request)
    {
        $input = [];

        if ($this->auth->user()->can('user::change-own-name')) {
            $input = array_merge($input, [
                'first_name' => $request->first_name,
                'last_name'  => $request->last_name,
            ]);
        }

        if ($this->auth->user()->can('user::change-own-email')) {
            $input = array_merge($input, [
                'email' => $request->email,
            ]);
        }

        $this->user->update($input, $this->auth->id());

        flash(trans('core::messages.resource.resource updated', ['name' => trans('user::profile.title.profile')]));

        return redirect()->back();
    }
646920
def update(address, new_address, options={})
      params = {:address => new_address}
      Mailgun.submit :put, list_url(address), params.merge(options)
    end
1259029
def update(cls, domain, source, dest_add, dest_del):
        """"""
        result = None

        if dest_add or dest_del:
            current_destinations = cls.get_destinations(domain, source)
            fwds = current_destinations[:]
            if dest_add:
                for dest in dest_add:
                    if dest not in fwds:
                        fwds.append(dest)
            if dest_del:
                for dest in dest_del:
                    if dest in fwds:
                        fwds.remove(dest)

            if ((len(current_destinations) != len(fwds))
                    or (current_destinations != fwds)):
                cls.echo('Updating mail forward %s@%s' % (source, domain))
                options = {'destinations': fwds}
                result = cls.call('domain.forward.update', domain, source,
                                  options)

        return result
1857
def update_groups_for_user(self, user: User, state: State = None):
        
        if state is None:
            state = user.profile.state
        for config in self.filter(states=state):
            # grant user new groups for their state
            config.update_group_membership_for_user(user)
        for config in self.exclude(states=state):
            # ensure user does not have groups from previous state
            config.remove_user_from_alliance_groups(user)
            config.remove_user_from_corp_groups(user)
167818
private void updatePrincipal() {

        principal = new JsonObject();
        profiles.forEach((name, profile) -> {
            final JsonObject jsonProfile = new JsonObject();
            profile.getAttributes()
                    .forEach((attributeName, attributeValue) ->
                            jsonProfile.put(attributeName, attributeValue.toString()));
            principal.put(name, jsonProfile);
        });
    }