def decorated(*args, **kwargs):
            data = request.data.decode('utf-8')
            try:
                request_json = json.loads(data)
            except (ValueError, KeyError, TypeError):
                return json_error('Use JSON to comunicate with our API')

            if not require_data:
                return f(request_json=request_json, *args, **kwargs)
            elif 'data' in request_json.keys():
                data = str(request_json['data']).strip()

                if required_data_words:
                    if len(data.split()) != required_data_words:
                        return json_error("Data must have %d word(s)!" %
                                          required_data_words)

                if required_data_characters:
                    if len(data) != required_data_characters:
                        return json_error("Data must have %d characters!" %
                                          required_data_characters)

                return f(data=data, request_json=request_json, *args, **kwargs)

            return json_error('Data not provided')

    def on_convert(self, request):
        if should_exclude_visitor(request):
            return json_success({'excluded': 'true'}, request)

        experiment_name = request.args.get('experiment')
        client_id = request.args.get('client_id')
        kpi = request.args.get('kpi', None)

        if client_id is None or experiment_name is None:
            return json_error({'message': 'missing arguments'}, request, 400)

        dt = None
        if request.args.get("datetime"):
            dt = dateutil.parser.parse(request.args.get("datetime"))

        try:
            alt = convert(experiment_name, client_id, kpi=kpi, datetime=dt, redis=self.redis)
        except ValueError as e:
            return json_error({'message': str(e)}, request, 400)

        resp = {
            'alternative': {
                'name': alt.name
            },
            'experiment': {
                'name': alt.experiment.name,
            },
            'conversion': {
                'value': None,
                'kpi': kpi
            },
            'client_id': client_id
        }

        return json_success(resp, request)

 def dispatch_request(self, request):
     adapter = self.url_map.bind_to_environ(request.environ)
     try:
         endpoint, values = adapter.match()
         return getattr(self, 'on_' + endpoint)(request, **values)
     except NotFound:
         return json_error({"message": "not found"}, request, 404)
     except HTTPException:
         return json_error({"message": "an internal error has occurred"}, request, 500)

def get(request):
    if not 'id' in request.GET:
        return json_error(1, arg1='id')
    try:
        result = Location.objects\
                         .values('id', 'longitude', 'latitude', 'last_update', 'date_created')\
                         .get(id=int(request.GET['id']))
    except (ObjectDoesNotExist, ValueError, TypeError):
        return json_error(2, arg1='id')

    return json_result(result)

 def dispatch_request_with_metrics(self, request):
     adapter = self.url_map.bind_to_environ(request.environ)
     try:
         endpoint, values = adapter.match()
         with self.statsd.timer('{}.response_time'.format(endpoint)):
             response = getattr(self, 'on_' + endpoint)(request, **values)
             self.statsd.incr('{}.count'.format(endpoint))
             self._incr_status_code(response.status_code)
             return response
     except NotFound:
         self._incr_status_code(404)
         return json_error({"message": "not found"}, request, 404)
     except HTTPException:
         self._incr_status_code(500)
         return json_error({"message": "an internal error has occurred"}, request, 500)

def comment_create():
    data = request.get_json()
    article = g.article
    
    form = CommentForm(**data)
    if form.validate():
        form_data = form.data
        form_data['user'] = g.user
        form_data['ip'] = request.remote_addr

        try:
            comment = article.create_comment(**form_data)
            article.update_comment_count()
            article.update_user_comment_count(user_id=comment.user_id)

            db_session.commit()

            cache.update_article(article.id, article)
            cache.update_sorted_articles(article, 'comment_count')
            return jsonify({"data": comment.json_data()})
        except ModelException, me:
            db_session.rollback()
            return json_error(type=me.type, messages=me.message)
        except Exception, e:
            logging.error(e)
            db_session.rollback()
            return json_error_database()

    def dispatch_request(self, request):
        adapter = self.url_map.bind_to_environ(request.environ)
        try:
            endpoint, values = adapter.match()

            if endpoint == 'participate' or endpoint == 'convert' or endpoint == 'experiment_details':
                self.set_redis_prefix(request)

            return getattr(self, 'on_' + endpoint)(request, **values)

        except ValueError as e:
          return json_error({'message': str(e)}, request, 400)
        except NotFound:
            return json_error({"message": "not found"}, request, 404)
        except HTTPException:
            return json_error({"message": "an internal error has occurred"}, request, 500)

def create():
    data = request.get_json()
    
    form = TopicForm(**data)
    if form.validate():
        form_data = form.data
        form_data['ip'] = request.remote_addr

        try:
            topic = g.user.create_topic(**form_data)
            alert = dict(
                type='success',
                messages=_("Your topic has been created successfully. You will be redirected to it shortly")
            )

            redirect = topic.get_url('view')
            cache.update_sorted_topics(topic, 'date_created')
            return jsonify({"data": topic.json_data(), "alert": alert, "redirect": redirect})
        except ModelException, me:
            db_session.rollback()
            return json_error(type=me.type, messages=me.message)
        except Exception, e:
            logging.error(e)
            db_session.rollback()
            return json_error_database()

def add(request):

    if not 'name' in request.GET:
        return json_error(1, arg1='name')

    if not 'location_id' in request.GET:
        return json_error(1, arg1='location_id')

    try:
        location = Location.objects.get(id=int(request.GET['location_id']))
    except (ObjectDoesNotExist, ValueError, TypeError):
        return json_error(2, arg1='location')

    result = Truck.objects.create(name=request.GET['name'], location=location)

    return json_result(result.id)

 def calculate_capacity(self):
     try:
        in_data = json_request()
        resource = in_data["Resource"]
        if not isinstance(resource, dict):
           raise Exception("Resource field is not an object!")
        
        if "Allocation" in in_data:
           allocation = in_data["Allocation"]
           if not isinstance(allocation,list):
              raise Exception("Allocation field is not an array!")
        else:
           allocation = {}
        
        if "Release" in in_data:
           release = in_data["Release"]
           if not isinstance(release, list):
              raise Exception("Release field is not an array!")              
        else:
           release = {} 
                   
        return json_reply(self._calculate_capacity(resource, allocation, release))
                     
     except Exception as e:           
        return json_error(e)   

    def on_participate(self, request):
        opts = {}
        alts = request.args.getlist('alternatives')
        experiment_name = request.args.get('experiment')
        force = request.args.get('force')
        client_id = request.args.get('client_id')
        distribution = request.args.get('traffic_dist')

        if client_id is None or experiment_name is None or alts is None:
            return json_error({'message': 'missing arguments'}, request, 400)

        if distribution:
            opts['distribution'] = distribution

        try:
            experiment = Experiment.find_or_create(experiment_name, alts, self.redis, opts)
        except ValueError as e:
            return json_error({'message': str(e)}, request, 400)

        alternative = None
        if force and force in alts:
            alternative = force
        elif not cfg.get('enabled', True):
            alternative = alts[0]
        elif experiment.winner is not None:
            alternative = experiment.winner
        elif should_exclude_visitor(request):
            alternative = alts[0]
        else:
            dt = None
            if request.args.get("datetime"):
                dt = dateutil.parser.parse(request.args.get("datetime"))
            client = Client(client_id, self.redis)
            alternative = experiment.get_alternative(client, dt=dt).name

        resp = {
            'alternative': {
                'name': alternative
            },
            'experiment': {
                'name': experiment.name,
            },
            'client_id': client_id,
            'status': 'ok'
        }

        return json_success(resp, request)

 def request_resources(self):
    try:
       managers = copy.copy(ManagersTreeView.managers)
       for id in managers:          
          self.request_resources_id(id)
       return json_reply({})
    except Exception as e:
       return json_error(e)

 def delete_managers(self):
     try:
        ManagersTreeView.managers = {}   
           
        return json_reply({})    
            
     except Exception as e:           
        return json_error(e)      

    def on_participate(self, request):
        alts = request.args.getlist('alternatives')
        experiment_name = request.args.get('experiment')
        force = request.args.get('force')
        record_force = to_bool(request.args.get('record_force', 'false'))
        client_id = request.args.get('client_id')
        traffic_fraction = request.args.get('traffic_fraction')

        if traffic_fraction is not None:
            traffic_fraction = float(traffic_fraction)
        prefetch = to_bool(request.args.get('prefetch', 'false'))

        if client_id is None or experiment_name is None or alts is None:
            return json_error({'message': 'missing arguments'}, request, 400)

        dt = None
        if request.args.get("datetime"):
            dt = dateutil.parser.parse(request.args.get("datetime"))
        try:
            if should_exclude_visitor(request):
                exp = Experiment.find(experiment_name, redis=self.redis)
                if exp.winner is not None:
                    alt = exp.winner
                else:
                    alt = exp.control
            else:
                alt = participate(experiment_name, alts, client_id,
                                  force=force, record_force=record_force,
                                  traffic_fraction=traffic_fraction,
                                  prefetch=prefetch, datetime=dt, redis=self.redis)
        except ValueError as e:
            return json_error({'message': str(e)}, request, 400)

        resp = {
            'alternative': {
                'name': alt.name
            },
            'experiment': {
                'name': alt.experiment.name,
            },
            'client_id': client_id,
            'status': 'ok'
        }

        return json_success(resp, request)

 def get_manager(self, id):
     try:
        if id in  ManagersTreeView.managers:
           return json_reply(ManagersTreeView.managers[id]) 
        
        raise Exception("invalid manager id: " + id)
            
     except Exception as e:           
        return json_error(e)       

def download_archive_stream(request, share, subdir=None):
#     try:
    selection = request.GET.get('selection').split(',')
    for item in selection:
        test_path(item)
    try:
        return share.create_archive_stream(items=selection,subdir=subdir)
    except Exception, e:
        return json_error([e.message])

def create_folder(request, share, subdir=None):
    form = FolderForm(request.POST)
    data = json_form_validate(form)
    if form.is_valid():
        folder_path = share.create_folder(form.cleaned_data['name'],subdir)
        (mode, ino, dev, nlink, uid, gid, size, atime, mtime, ctime) = os.stat(folder_path)
        data['objects']=[{'name':form.cleaned_data['name'],'modified':datetime.datetime.fromtimestamp(mtime).strftime("%m/%d/%Y %I:%M %p")}]
        ShareLog.create(share=share,user=request.user,action=ShareLog.ACTION_FOLDER_CREATED,paths=[form.cleaned_data['name']],subdir=subdir)
        return json_response(data)
    else:
        return json_error([error for name, error in form.errors.items()])

 def get_managers(self):
     try:
        mgrs = []
        
        for i in ManagersTreeView.managers:
           mgrs.append(ManagersTreeView.managers[i])
           
        return json_reply(mgrs)    
            
     except Exception as e:           
        return json_error(e)      

def create():
    data = request.get_json()
    
    form = QuestionForm(**data)
    if form.validate():
        form_data = form.data
        form_data['ip'] = request.remote_addr
        question = g.user.create_question(**form_data)
        
        return jsonify({"data": question.json_data()})
    else:
        return json_error(type="VALIDATION_FAILED", messages=form.errors)

    def delete_manager(self, id):
        try:
           print "Unregistering %s" % id
           if id in  ManagersTreeView.managers:
              item = ManagersTreeView.managers[id]
              key = ManagersTreeView.gen_key(item['Name'], item['Address'], item['Port'])
              self._deleteManager(item['Name'], item['Address'], item['Port'], id)
              ManagersTreeView.managers.pop(id)
              return json_reply({})          
 
        except Exception as e:           
           return json_error(e)