Unlocks Drop user.

@param Drop $drop

@return Drop
170740
public function unlockDropUser(Drop $drop)
    {
        $this->om->startFlushSuite();

        $drop->setUnlockedUser(true);
        $dropzone = $drop->getDropzone();
        $users = [];

        switch ($dropzone->getDropType()) {
            case Dropzone::DROP_TYPE_USER:
                $users = [$drop->getUser()];
                break;
            case Dropzone::DROP_TYPE_TEAM:
                $users = $drop->getUsers();
                break;
        }
        $this->checkCompletion($dropzone, $users, $drop);
        $this->om->persist($drop);

        $this->om->endFlushSuite();

        return $drop;
    }
33764
public static function uunlock($lock) {
        try {
            $redis = RedisClient::getRedis();
            if ($redis) {
                $redis->del($lock);
            }
        } catch (\Exception $e) {
            log_warn($e->getMessage(), 'redis_lock');
        }
    }
331021
public function deleteDrop(Drop $drop)
    {
        $this->om->startFlushSuite();
        $documents = $drop->getDocuments();

        foreach ($documents as $document) {
            $this->deleteDocument($document);
        }
        $this->om->remove($drop);
        $this->om->endFlushSuite();
    }
1065135
public function down()
    {
        // Disable foreign key constraints or these DROPs will not work
        DB::statement('SET FOREIGN_KEY_CHECKS = 0');


        Schema::table('user_group', function($table){
            $table->dropIndex('user_group_user_id_index');
            $table->dropIndex('user_group_group_id_index');
        });
        Schema::dropIfExists('user_group');


        Schema::table('groups', function($table){
            $table->dropIndex('groups_title_unique');
            $table->dropForeign('groups_created_by_foreign');
            $table->dropForeign('groups_updated_by_foreign');
            $table->dropForeign('groups_locked_by_foreign');
        });
        Schema::dropIfExists('groups');


        Schema::drop('password_resets');


        Schema::table('users', function($table){
            $table->dropIndex('users_email_unique');
        });
        Schema::dropIfExists('users');


        // Enable foreign key constraints
        DB::statement('SET FOREIGN_KEY_CHECKS = 1');
	}
977753
public function getDropForeignKeyDDL(ForeignKey $fk)
    {
        if ($fk->isSkipSql()) {
            return;
        }
        $pattern = "
ALTER TABLE %s DROP CONSTRAINT %s;
";

        return sprintf($pattern,
            $this->quoteIdentifier($fk->getTable()->getName()),
            $this->quoteIdentifier($fk->getName())
        );
    }
1082185
public function unlock()
    {
        if ($this->fp !== null) {
            flock($this->fp, LOCK_UN);
            fclose($this->fp);
            $this->fp = null;
        }

        return true;
    }
1030405
public function unlock () {
        if (!$this->beforeUnlock ()) {
            return false;
        }
        $redis = $this->getConnection ()->getClient ();
        $value = $redis->get ($this->name);
        $decimalPlaces = max (strlen (substr ($value , strpos ($value , "."))) , strlen (substr ($this->_expiresAt , strpos ($this->_expiresAt , ".")))) - 1;
        if (bccomp ($value , $this->_expiresAt , $decimalPlaces) == -1 && bccomp ($value , microtime (true) , $decimalPlaces) == 1) {
            return false;
        }


        $redis->delete ($this->name);
        $this->afterUnlock ();
        return true;
    }
883499
public function disconnect($drop = false)
    {
        $this->handler->onClose($this);
        parent::disconnect($drop);
    }
1089911
function dropPrivileges() {
  var strInfo;
  if (process.setgid) {
    var group = config.group;
    if (typeof group === 'string') {
      process.setgid(group);
      strInfo = group;
    }
  }
  if (process.setuid) {
    var user = config.user;
    if (typeof user === 'string') {
      process.setuid(user);
      if (strInfo)
        strInfo = user + ":" + strInfo;
      else
        strInfo = user;
    }
  }
  if (!droppedPrivileges && strInfo)
    logNotice("Dropped privileges to: " + strInfo);
  droppedPrivileges = true;
}
1163283
public function drop()
    {

        static::valTable();
        $sql = /** @lang text */
            "DROP TABLE " . self::$table;
        try {
            $this->exec($sql);
            static::$response["status"] = "success";
            static::$response["response"] = "success";
            return self::terminate(static::$response);

        } catch (Exception $e) {
            static::$response["status"] = "error";
            static::$response["response"] = $e->getMessage();
            static::$response["code"] = $e->getCode();
            return static::terminate(static::$response);
        }

    }
950207
public function release_lock($key) {
        $key = $this->parse_key($key);
        if ($this->nativelocking) {
            return $this->get_store()->release_lock($key, $this->get_identifier());
        } else {
            $this->ensure_cachelock_available();
            return $this->cachelockinstance->unlock($key, $this->get_identifier());
        }
    }
1359061
public function getDropIndexDDL(Index $index)
    {
        $pattern = "
DROP INDEX %s;
";

        return sprintf($pattern,
            $this->quoteIdentifier($index->getFQName())
        );
    }
602751
public function drop($ifExists = false)
    {
        $databases = $this->db->listDatabases();

        if (!in_array($this->getName(), $databases, true)) {
            return $this;
        }

        if ($this->getName() === $this->db->getDatabase()->getName()) {
            $this->db->disconnect();
            $this->db->setDatabaseName(null);
            $this->db->connect();
        }

        $query = $this->db->getQuery(true);

        $this->db->setQuery(
            $query->format('ALTER DATABASE %n SET SINGLE_USER WITH ROLLBACK IMMEDIATE', $this->name)
        )->execute();

        $sql = SqlsrvGrammar::dropDatabase($this->name, $ifExists);

        $this->db->setQuery($sql)->execute();

        return $this;
    }
1197799
public function lock($locked = true)
    {
        $this->_locked = $locked === false ? false : true;
        return $this;
    }
558273
public function unlock()
    {
        $user = UserHelper::getUser($this->getUserResource());

        if ($this->getUserLocksService()->unlockUser($user)) {
            $this->returnJson(['success' => true, 'message' => __('User %s successfully unlocked', UserHelper::getUserLogin(UserHelper::getUser($user)))]);
        } else {
            $this->returnJson(['success' => false, 'message' => __('User %s can not be unlocked', UserHelper::getUserLogin(UserHelper::getUser($user)))]);
        }
    }
1339918
public function release()
    {
        if ($this->locked) {
            flock($this->fp, LOCK_UN);
            fclose($this->fp);

            $this->fp = null;
            $this->locked = false;
        }

        return $this;
    }
582441
public function drop($label)
    {
        $blueprint = $this->createBlueprint($label);

        $blueprint->drop();

        return $this->build($blueprint);
    }