gets the app name from the request
340202
function(request, response, next){
		var apptkn;
		if (!utils.Misc.isNullOrUndefined(request.get(X_BOLT_APP_TOKEN))) {
			apptkn = request.get(X_BOLT_APP_TOKEN);
		}
		else {
			var error = new Error(errors['110']);
			response.end(utils.Misc.createResponse(null, error, 110));
			return;
		}

		var name = __getAppFromAppToken(apptkn, request);
		if (utils.Misc.isNullOrUndefined(name)) {
			var error = new Error(errors['113']);
			response.end(utils.Misc.createResponse(null, error, 113));
			return;
		}
		var appnm = utils.String.trim(name.toLowerCase());
		request.appName = appnm;

		next();
	}
175295
private function asksForApplicationName(): string
    {
        if (empty($name = $this->input->getArgument('name'))) {
            $name = $this->ask('What is your application name?');
        }

        if (empty($name)) {
            $name = trim(basename($this->app->basePath()));
        }

        return Str::lower($name);
    }
149285
protected static String getApplicationName(Context ctx) {
        try {
            ApplicationInfo applicationInfo = ctx.getApplicationInfo();
            int stringId = applicationInfo.labelRes;
            if (stringId == 0) {
                if (applicationInfo.nonLocalizedLabel != null) {
                    return applicationInfo.nonLocalizedLabel.toString();
                }
            } else {
                return ctx.getString(stringId);
            }
        } catch (Exception e) {
            Log.e(TAG, "Error getting application name.", e);
        }

        return null;
    }
407799
def get_apps(self):
        
        apps = []
        for resource in self._get_apps()['resources']:
            apps.append(resource['entity']['name'])

        return apps
540474
def pin_cookie_name(self):
        """"""
        if not hasattr(self, "_pin_cookie"):
            self._pin, self._pin_cookie = get_pin_and_cookie_name(self.app)
        return self._pin_cookie
1265210
def get_app_guid(self, app_name):
        
        summary = self.space.get_space_summary()
        for app in summary['apps']:
            if app['name'] == app_name:
                return app['guid']
692881
def find_application(app_id=None, app_name=None):
        
        LOGGER.debug("ApplicationService.find_application")
        if (app_id is None or not app_id) and (app_name is None or not app_name):
            raise exceptions.ArianeCallParametersError('id and name')

        if (app_id is not None and app_id) and (app_name is not None and app_name):
            LOGGER.warn('ApplicationService.find_application - Both id and name are defined. '
                        'Will give you search on id.')
            app_name = None

        params = None
        if app_id is not None and app_id:
            params = {'id': app_id}
        elif app_name is not None and app_name:
            params = {'name': app_name}

        ret = None
        if params is not None:
            args = {'http_operation': 'GET', 'operation_path': 'get', 'parameters': params}
            response = ApplicationService.requester.call(args)
            if response.rc == 0:
                ret = Application.json_2_application(response.response_content)
            elif response.rc != 404:
                err_msg = 'ApplicationService.find_application - Problem while finding application (id:' + \
                          str(app_id) + ', name:' + str(app_name) + '). ' + \
                          'Reason: ' + str(response.response_content) + '-' + str(response.error_message) + \
                          " (" + str(response.rc) + ")"
                LOGGER.warning(
                    err_msg
                )

        return ret
310948
def name(self):
        
        try:
            return self.config_parser.get('application', 'name')
        except CONFIGPARSER_EXC:
            return super(IniConfig, self).name
176518
function list(appName, callback) {
    var uri = format('/%s/apps/%s/config/', deis.version, appName);
    commons.get(uri, function onListResponse(err, result) {
      callback(err, result ? result.values : null);
    });
  }
1364176
function guessAppName (compilerWorkingDirectory) {
  var packageJson = path.resolve(compilerWorkingDirectory, 'package.json');
  if (!fs.existsSync(packageJson)) {
    packageJson = path.resolve(compilerWorkingDirectory, '../package.json');
    if (!fs.existsSync(packageJson)) {
      return 'Webpack App';
    }
  }
  return JSON.parse(fs.readFileSync(packageJson)).name;
}
72800
def get_application(self, id=None, name=None):
        
        log.info("Picking application: %s (%s)" % (name, id))
        return self.applications[id or name]
304120
function list(appName, callback) {
    var url = format('/%s/apps/%s/config/', deis.version, appName);
    commons.get(url, function onListResponse(err, result) {
      callback(err, result ? result.tags : null);
    });
  }
295988
def detect_appname(target)
      return "app.rb" if File.exist?(File.join(self.target, "app.rb"))
      return "application.rb" if File.exist?(File.join(self.target, "application.rb"))
      file_array = Dir.glob(File.join("#{target}", "*.rb"))
      return file_array[0] if ! file_array.nil? and file_array.count == 1
      return "" # gracefully failure
    end
675722
public static function getApplicationName():?string
    {
        if (self::isCliApp()) {
            return self::$APPLICATION_NAME;
        }

        return MSession::get(MCoreApplication::APPLICATION_NAME);
    }
643519
def application_name(self):
        
        if self._application_name is None and self.units:
            self._application_name = self.units[0].unit_name.split('/')[0]
        return self._application_name
1192070
function getName(tuple) {
    if (Array.isArray(tuple)) {
      var verb = tuple[0]
      var path = getLambdaName(tuple[1])
      return [`${app}-production-${verb}${path}`, `${app}-staging-${verb}${path}`]
    }
    else {
      var path = getLambdaName(tuple)
      return [`${app}-production-get${path}`, `${app}-staging-get${path}`]
    }
  }
883149
function getname(req, res) {
  res.send(null, req.conn.client.name);
}