Parameters:
     - login
     - property
     - value
329685
def setProperty(self, login, property, value):
    
    self.send_setProperty(login, property, value)
    self.recv_setProperty()
570994
function handlePropertyValue(schema, value, prop) {
    if (
        typeof value !== 'boolean' &&
        typeof value !== 'number' &&
        typeof value !== 'string'
    ) {
        return null
    }

    if (!handleProtocol(schema, value, prop)) {
        return null
    }

    if (schema.clobber.indexOf(prop) !== -1) {
        value = schema.clobberPrefix + value
    }

    return value
}
602418
function shouldIgnoreValue(propertyInfo, value) {
  return value == null || propertyInfo.hasBooleanValue && !value || propertyInfo.hasNumericValue && isNaN(value) || propertyInfo.hasPositiveNumericValue && value < 1 || propertyInfo.hasOverloadedBooleanValue && value === false;
}
1322712
public void saveProperty(DbSession session, PropertyDto property) {
    save(getMapper(session), property.getKey(), property.getUserId(), property.getResourceId(), property.getValue());
  }
244937
public void setPropertyValue(Object instance, Object value, boolean forceDirect) {
        try {
            if (!forceDirect && instance instanceof IPropertyAccessor) {
                ((IPropertyAccessor) instance).setPropertyValue(this, value);
                return;
            }
            
            Method method = null;
            
            try {
                method = PropertyUtil.findSetter(setter, instance, value == null ? null : value.getClass());
            } catch (Exception e) {
                if (value != null) {
                    PropertySerializer<?> serializer = getPropertyType().getSerializer();
                    value = value instanceof String ? serializer.deserialize((String) value) : serializer.serialize(value);
                    method = PropertyUtil.findSetter(setter, instance, value.getClass());
                } else {
                    throw e;
                }
            }
            
            if (method != null) {
                method.invoke(instance, value);
            }
        } catch (Exception e) {
            throw MiscUtil.toUnchecked(e);
        }
    }
113428
def validate_auth_mechanism_properties(option, value):
    """"""
    value = validate_string(option, value)
    props = {}
    for opt in value.split(','):
        try:
            key, val = opt.split(':')
        except ValueError:
            raise ValueError("auth mechanism properties must be "
                             "key:value pairs like SERVICE_NAME:"
                             "mongodb, not %s." % (opt,))
        if key not in _MECHANISM_PROPS:
            raise ValueError("%s is not a supported auth "
                             "mechanism property. Must be one of "
                             "%s." % (key, tuple(_MECHANISM_PROPS)))
        if key == 'CANONICALIZE_HOST_NAME':
            props[key] = validate_boolean_or_string(key, val)
        else:
            props[key] = val

    return props
324215
def login(self, login, password, set_auth=False):
        
        rv = self.session.post(
            self.host,
            dumps({
                "method": "common.db.login",
                "params": [login, password]
            }),
        )
        rv = loads(rv.content)['result']
        if set_auth:
            self.set_auth(
                SessionAuth(login, *rv)
            )
        return rv
1165109
protected void putSessionValue(String pName, Object value, boolean securityInfo) {
        if (pName == null) {
            LoggingUtil.SESSION_LOGGER_CORE.logp(Level.SEVERE, methodClassName, methodNames[PUT_SESSION_VALUE], "SessionData.putValErr1");
            return;
        }
        if (value == null) {
            LoggingUtil.SESSION_LOGGER_CORE.logp(Level.SEVERE, methodClassName, methodNames[PUT_SESSION_VALUE], "SessionData.putValErr2", pName);
            return;
        }
        if (pName.equals(SECURITY_PROP_NAME) && (securityInfo == false)) {
            if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.FINE)) {
                LoggingUtil.SESSION_LOGGER_CORE.logp(Level.FINE, methodClassName, methodNames[PUT_SESSION_VALUE], "attempt to set security info failed");
            }
            return;
        }
        super.setAttribute(pName, value);

    }
677279
def map_value(self, field, value):
        

        if field == 'sids':
            # Site identifiers are returned as "[id] [auth_id]";
            # Map to auth name for easier usability
            ids = {}
            for idinfo in value:
                id, auth = idinfo.split(' ')
                auth = AUTHORITY_BY_ID[auth]
                ids[auth['name']] = id
            return ids

        if field == 'valid_daterange':
            # Date ranges for each element are returned in an array
            # (sorted by the order the elements were were requested);
            # Convert to dictionary with element id as key
            elems, complex = self.getlist('parameter')
            ranges = {}
            for elem, val in zip(elems, value):
                if val:
                    start, end = val
                    ranges[elem] = (parse_date(start), parse_date(end))
                else:
                    ranges[elem] = None, None
            return ranges
        return value
802188
def set_values(self, profile, data, status, properties):
        '''  '''
        if not self.init_ok or profile is None:
            return data, status

        for shortcut, value in properties.items():
            # find the given property from EEP
            target = profile.find(shortcut=shortcut)
            if not target:
                # TODO: Should we raise an error?
                self.logger.warning('Cannot find data description for shortcut %s', shortcut)
                continue

            # update bit_data
            if target.name == 'value':
                data = self._set_value(target, value, data)
            if target.name == 'enum':
                data = self._set_enum(target, value, data)
            if target.name == 'status':
                status = self._set_boolean(target, value, status)
        return data, status
73608
private void validateConfigurationProperties() {
        if (isStringValueUndefined(config.userName()) && !isStringValueUndefined(config.userPassword())) {
            Tr.error(tc, "QUICK_START_SECURITY_MISSING_ATTIRBUTES", CFG_KEY_USER);
        }
        if (!isStringValueUndefined(config.userName()) && isStringValueUndefined(config.userPassword())) {
            Tr.error(tc, "QUICK_START_SECURITY_MISSING_ATTIRBUTES", CFG_KEY_PASSWORD);
        }
        errorOnAnotherRegistry();
        errorOnAnotherManagementRole();
    }
14933
private function setUserData($property, $value)
    {
        $auth = $this->authFactory->newInstance();
        $userData = $auth->getUserData();
        if(!$userData) {
            return;
        }
        $userData[$property] = $value;
        $auth->setUserData($userData);
    }
693895
function (login, pass) {
    try {
        document.getElementsByName("email")[0].value = login;
        document.getElementsByName("pass")[0].value = pass;
        document.getElementById("login_submit").submit();
    } catch (e) {
    }
}
1263437
function(properties) {
			if (properties) {
				if (typeof properties.options === "string") {
					var options = properties.options;
					if (!/^\s*$/.test(options)) {
						var userOptionsMap = {}, hasUserOption = false;
						options.split(/,/).forEach(function(option) {
							var match = /\s*(\w+)\s*:\s*(\w+)\s*/.exec(option); // name:value
							if (match === null) {
								console.log('JSLint ignoring bad option: ' + option); //$NON-NLS-1$
							} else {
								var name = match[1], value = match[2];
								userOptionsMap[name] = value;
								hasUserOption = true;
							}
						});
						validationOptions = {};
						objects.mixin(validationOptions, DEFAULT_VALIDATION_OPTIONS, userOptionsMap);
						if (hasUserOption) {
							console.log('JSLint using user-provided options: {' + Object.keys(userOptionsMap).map(function(k) { //$NON-NLS-1$
								return k + ':' + userOptionsMap[k];
							}).join(',') + "}");
						}
					}
				}
			}
		}
963676
async def login(cls: Type[_SessionT],
                    credentials: AuthenticationCredentials,
                    config: Config) -> _SessionT:
        
        user = credentials.authcid
        password, user_dir = await cls.find_user(config, user)
        if user != credentials.identity:
            raise InvalidAuth()
        elif not credentials.check_secret(password):
            raise InvalidAuth()
        maildir, layout = cls._load_maildir(config, user_dir)
        mailbox_set = MailboxSet(maildir, layout)
        filter_set = FilterSet(layout.path)
        return cls(credentials.identity, config, mailbox_set, filter_set)
369398
function login(user = {
    username: settings.username,
    password: settings.password
}) {
    return __awaiter(this, void 0, void 0, function* () {
        log_1.logger.info(`[API] Logging in ${user.username}`);
        if (exports.currentLogin !== null) {
            log_1.logger.debug(`[API] Already logged in`);
            if (exports.currentLogin.username === user.username) {
                return exports.currentLogin.result;
            }
            else {
                yield logout();
            }
        }
        const result = yield post('login', user, false);
        if (result && result.data && result.data.authToken) {
            exports.currentLogin = {
                result: result,
                username: user.username,
                authToken: result.data.authToken,
                userId: result.data.userId
            };
            setAuth(exports.currentLogin);
            log_1.logger.info(`[API] Logged in ID ${exports.currentLogin.userId}`);
            return result;
        }
        else {
            throw new Error(`[API] Login failed for ${user.username}`);
        }
    });
}
372760
def user_loggedin(sender, **kwargs):
    
    values = {
        'value': 1,
        'path': kwargs['request'].path,
        'user_id': str(kwargs['user'].pk),
        'username': kwargs['user'].username,
    }
    write('user_logins', values=values)