Get the map currently stored with the subscription
330765
public Map getUserProperties()
    {
      if (tc.isEntryEnabled())
        SibTr.entry(tc, "getUserProperties");
      
      Map map = _consumerDispatcher.getConsumerDispatcherState().getUserData();
      
      if (tc.isEntryEnabled())
        SibTr.exit(tc, "getUserProperties", map);
      return map;
    }
333045
function map() {
  var cache = {};
  if (!cache.extensions) cache.extensions = require('./lib/exts.json');
  if (!cache.languages) cache.languages = require('./lib/lang.json');
  return cache;
}
19467
def get(self):
        
        subscription_tracking = {}
        if self.enable is not None:
            subscription_tracking["enable"] = self.enable

        if self.text is not None:
            subscription_tracking["text"] = self.text.get()

        if self.html is not None:
            subscription_tracking["html"] = self.html.get()

        if self.substitution_tag is not None:
            subscription_tracking["substitution_tag"] = \
                self.substitution_tag.get()
        return subscription_tracking
851744
def _get_maps_from_user(self, user):
        
        req = Session.query(Map).select_from(join(Map, User))
        return req.filter(User.login==user).all()
355190
function loadSavedState () {
    var output;
    try {
        output = jsonfile.readFileSync(STATE_FILE);
    } catch (ex) {
        winston.info('No previous state found, continuing');
        output = {
            subscriptions: [],
            callback: '',
            history: {},
            version: '0.0.0'
        };
    }
    return output;
}
582999
def getResourceSubscription(self,ep,res):
		'''
		
		'''
		result = asyncResult()
		result.endpoint = ep
		result.resource = res
		data = self._getURL("/subscriptions/"+ep+res)
		if data.status_code == 200: #immediate success
			result.error = False
			result.is_done = True
			result.result = data.content
		else:
			result.error = response_codes("unsubscribe",data.status_code)
			result.is_done = True
		result.raw_data = data.content
		result.status_code = data.status_code
		return result
1287006
def _new_map_from_user(self, user, name, filepath):
        
        map = Map(name, filepath)
        map.user = Session.query(User).filter(User.login==user).one()
        Session.add(map)
        Session.commit()
        return map
1093784
def fetch(self):
        
        params = values.of({})

        payload = self._version.fetch(
            'GET',
            self._uri,
            params=params,
        )

        return SyncMapItemInstance(
            self._version,
            payload,
            service_sid=self._solution['service_sid'],
            map_sid=self._solution['map_sid'],
            key=self._solution['key'],
        )
755359
private Map<String, List<String>> map() throws IOException {
        if (this.saved.isEmpty()) {
            this.saved.add(this.freshMap());
        }
        return this.saved.get(0);
    }
1032250
def _mapper(self):
        
        return {
            'card': Payment.Card,
            'customer': Payment.Customer,
            'hosted_payment': Payment.HostedPayment,
            'notification': Payment.Notification,
            'failure': Payment.Failure,
        }
1231047
def getPreSubscription(self):
		'''
		
		'''
		result = asyncResult()
		data = self._getURL("/subscriptions")
		if data.status_code == 200: #immediate success
			result.error = False
			result.is_done = True
			result.result = data.json()
		else:
			result.error = response_codes("presubscription",data.status_code)
			result.is_done = True
		result.raw_data = data.content
		result.status_code = data.status_code
		return result
1011224
public Map<String, Boolean> getApprovalMap() throws ProposalException {

        Lifecycle.QueryApprovalStatusResults rs = getApprovalStatusResults();
        if (rs == null) {
            return Collections.emptyMap();
        }
        return rs.getApprovedMap();
    }
1250326
def get_subscription_labels(self, userPk):
        """"""
        r = self._request('subscriptions/' + str(userPk))
        if r:
            s = r.json()
            return s
        return []
746944
function _get_subscription( $license_id ) {
            if ( ! isset( $this->_storage->subscriptions ) ||
                 empty( $this->_storage->subscriptions )
            ) {
                return null;
            }

            foreach ( $this->_storage->subscriptions as $subscription ) {
                if ( $subscription->license_id == $license_id ) {
                    return $subscription;
                }
            }

            return null;
        }
709078
def _map(self, data_item):
        ""
        delegate = self.delegate
        logger.debug(f'mapping: {data_item}')
        if self.clobber or not self.exists(data_item.id):
            logger.debug(f'exist: {data_item.id}: {self.exists(data_item.id)}')
            delegate.dump(data_item.id, data_item)
1203762
function getAtlas(key) {
         if (typeof key === "string") {
           return this.atlases.get(key);
         } else {
           return this.atlases.values().next().value;
         }
       }
739674
def _get_map_from_user_by_id(self, user, map_id):
        
        req = Session.query(Map).select_from(join(Map, User))
        try:
            return req.filter(and_(User.login==user, Map.id==map_id)).one()
        except Exception, e:
            return None