def _do_update_from_json(
         self, json, parse_def, aliases, ctx, permissions,
         user_id, duplicate_error=True):
     # TODO: Verify uniqueness
     json_user_id = json.get('user', None)
     if json_user_id is None:
         json_user_id = user_id
     else:
         json_user_id = User.get_database_id(json_user_id)
         # Do not allow changing user
         if self.user_id is not None and json_user_id != self.user_id:
             raise HTTPBadRequest()
     self.user_id = json_user_id
     role_name = json.get("role", None)
     if not (role_name or self.role_id):
         role_name = R_PARTICIPANT
     if role_name:
         role = self.db.query(Role).filter_by(name=role_name).first()
         if not role:
             raise HTTPBadRequest("Invalid role name:"+role_name)
         self.role = role
     json_discussion_id = json.get('discussion', None)
     if json_discussion_id:
         from .discussion import Discussion
         json_discussion_id = Discussion.get_database_id(json_discussion_id)
         # Do not allow change of discussion
         if self.discussion_id is not None \
                 and json_discussion_id != self.discussion_id:
             raise HTTPBadRequest()
         self.discussion_id = json_discussion_id
     else:
         if not self.discussion_id:
             raise HTTPBadRequest()
     return self

	def dump_data(self,json):
		self._count = json.get("count")
		self._hex_count = json.get("hexcodecount")
		self._name = json.get("name")

		self.set_count(self._count)
		self.set_hex_count(self._hex_count)
		self.set_name(self._name)

 def _set_artist(self, json):
     if json.get('artistId'):
         id = json['artistId']
         self.artist = Artist(id)
         self.artist._set(json)
     elif json.get('artistName'):
         self.artist = json['artistName']
     else:
         self.artist = None

	def shallow_diver(self,json,shell):
		for key, value in json.iteritems():
			if shell == key:
				data = json.get(shell)
				break
			else:
				if shell in value:
					data = json.get(key)
					data = self.shallow_diver(data,shell)
		return data

    def _set(self, json):
        super(Album, self)._set(json)
        # Collection information
        self.name = json['collectionName']
        self.url = json.get('collectionViewUrl', None)
        self.amg_id = json.get('amgAlbumId', None)

        self.price = round(json.get('collectionPrice', 0) or 0, 4)
        self.price_currency = json['currency']
        self.track_count = json['trackCount']
        self.copyright = json.get('copyright', None)

        self._set_artist(json)

def get_orders(url, params):
    json = get_json(url, params)
    # print json
    data = json.get("return")
    orders = data.get("bids"), data.get("asks")
    # print orders
    return orders

    def _set(self, json):
        super(Track, self)._set(json)
        # Track information
        self.name = json['trackName']
        self.url = json.get('trackViewUrl', None)
        self.preview_url = json.get('previewUrl', None)
        self.price = None
        if json.has_key('trackPrice') and json['trackPrice'] is not None:
            self.price = round(json['trackPrice'], 4)
        self.number = json.get('trackNumber', None)
        self.duration = None
        if json.has_key('trackTimeMillis') and json['trackTimeMillis'] is not None:
            self.duration = round(json.get('trackTimeMillis', 0.0)/1000.0, 2)

        self._set_artist(json)
        self._set_album(json)

def get_orders2(url):
    params = get_query_parameters(url)
    json = get_json(url, params)
    # print json
    data = json.get("return")
    if url.find("mtgox") != -1:
        bids = []
        bidsJson = data.get("bids")
        for bid in bidsJson:
            b = []
            b.append(bid.get("price"))
            b.append(bid.get("amount"))
            bids.append(b)

        asks = []
        asksJson = data.get("asks")
        for ask in asksJson:
            b = []
            b.append(ask.get("price"))
            b.append(ask.get("amount"))
            asks.append(b)

        return bids, asks
    else:
        orders = data.get("bids"), data.get("asks")
        # print orders
        return orders

 def _set(self, json):
     super(Track, self)._set(json)
     # Track information
     self.name = json['trackName']
     self.url = json.get('trackViewUrl', None)
     self.preview_url = json.get('previewUrl', None)
     self.price = None
     if 'trackPrice' in json and json['trackPrice'] is not None:
         self.price = round(json['trackPrice'], 4)
     self.number = json.get('trackNumber', None)
     self.duration = None
     if 'trackTimeMillis' in json and json['trackTimeMillis'] is not None:
         self.duration = round(json.get('trackTimeMillis', 0.0)/1000.0, 2)
     try:
         self._set_artist(json)
     except KeyError:
         self.artist = None
     try:
         self._set_album(json)
     except KeyError:
         self.album = None

    def weixin_validate_data(self, xml):
        json = {}
        for el in etree.fromstring(xml):
            json[el.tag] = el.text

        acquirer = request.env['payment.acquirer'].search(
            [('weixin_appid', '=', json.get('appid'))], limit=1
        )

        _KEY = acquirer.weixin_key
        _logger.info('weixin key: %s' % _KEY)
        if not _KEY:
            return False

        _, prestr = util.params_filter(json)
        mysign = util.build_mysign(prestr, _KEY, 'MD5')
        if mysign != json.get('sign'):
            return False

        _logger.info('weixin: data validated!')
        return True

    def weixin_validate_data(self, **post):
        cr, uid, context = request.cr, request.uid, request.context
        json = {}
        for el in etree.fromstring(post):
            json[el.tag] = el.text

        _KEY = request.registry['payment.acquirer']._get_weixin_key()
        _, prestr = util.params_filter(json)
        mysign = util.build_mysign(prestr, _KEY, 'MD5')
        if mysign != json.get('sign'):
            return 'false'

        _logger.info('weixin: validated data')
        return request.registry['payment.transaction'].form_feedback(cr, SUPERUSER_ID, json, 'weixin',
                                                                     context=context)

	def dump_data(self,json):
		self._decoded = json.get("decoded")
		self._encoded = json.get("encoded")
		self._hex = json.get("hex")
		self._id = json.get("id")
		self._length = json.get("length")
		self._hash = json.get("md5")
		self._suspicious = json.get("suspicious")
		self._version = json.get("version")

		self.set_decoded(self._decoded)
		self.set_encoded(self._encoded)
		self.set_hex(self._hex)
		self.set_id(self._id)
		self.set_length(self._length)
		self.set_hash(self._hash)
		self.set_suspicious(self._suspicious)
		self.set_version(self._version)

    def read(self, jsonld, discussion, admin_user_id, base=None):
        if isinstance(jsonld, (str, unicode)):
            jsonld = json.loads(jsonld)
        c = jsonld['@context']
        # Avoid loading the main context.
        if c == context_url:
            c = local_context_loc
        elif context_url in c:
            c.remove(context_url)
            c.append(local_context_loc)
        c = Context(c, base=base)
        by_id = dict()
        site_iri = None

        def find_objects(j):
            if isinstance(jsonld, (str, unicode)):
                return
            if isinstance(j, list):
                for x in j:
                    find_objects(x)
            if isinstance(j, dict):
                jid = j.get('@id', None)
                if jid:
                    by_id[jid] = j
                for x in j.values():
                    find_objects(x)
        find_objects(jsonld)
        for json in by_id.itervalues():
            if json.get('@type', None) == 'Site':
                site_iri = json['@id']
                break
        site_iri = site_iri or base
        assert site_iri is not None
        handler = ImportRecordHandler(discussion, site_iri)
        for json in by_id.itervalues():
            cls = self.class_from_type(json['@type'])
            if not cls:
                print "missing cls for :", json['@type']
                continue
            if cls:
                cls = get_named_class(cls)
            cls.create_from_json(
                json, admin_user_id, aliases=handler,
                parse_def_name='readcif.json', jsonld=by_id)

 def update_from_json(self, json, user_id=Everyone, ctx=None):
     from ..auth.util import user_has_permission
     if user_has_permission(self.discussion_id, user_id, P_ADMIN_DISC):
         new_type = json.get('@type', self.type)
         if self.type != new_type:
             polymap = inspect(self.__class__).polymorphic_identity
             if new_type not in polymap:
                 return None
             new_type = polymap[new_type].class_
             new_instance = self.change_class(new_type)
             return new_instance.update_from_json(json, user_id, ctx)
         if 'settings' in json:
             self.settings_json = json['settings']
         if 'discussion' in json:
             self.discussion = Discussion.get_instance(json['discussion'])
     if 'state' in json:
         self.state_json = json['state']
     if user_id and user_id != Everyone and 'user_state' in json:
         self.set_user_state(json['user_state'], user_id)
     return self

 def _set_genres(self, json):
     self.genres = json.get('genres', None)

 def _set_screenshots(self, json):
     self.screenshots = json.get('screenshotUrls', None)

 def _set_description(self, json):
     self.description = json.get('description', None)

 def _set_price(self, json):
     self.price = json.get('price', None)

 def _set_version(self, json):
     self.version = json.get('version', None)

 def _set_artist(self, json):
     self.artist = None
     if json.get('artistId'):
         id = json['artistId']
         self.artist = Artist(id)
         self.artist._set(json)