def callback(request, auth_name):
    if auth_name == 'dropbox':
        post_dict = parser.parse(request.POST.urlencode())
        code = str(post_dict['code'])
        userid = str(post_dict['userid'])
        json_response = dbauth.handleCallback(userid, code, request)
        return HttpResponse(json_response)

    if auth_name == 'google':
        post_dict = parser.parse(request.POST.urlencode())
        code = str(post_dict['code'])
        json_response = gauth.handleCallback(code, request)
        return HttpResponse(json_response)

    return HttpResponse('Invalid URL')

def trainamodel(request):
    data = {}
    try:
        post_dict = parser.parse(request.POST.urlencode())

        socketid = post_dict['socketid']
        log_to_terminal('Beginning training a new model', post_dict['socketid'])

        old_save_dir = conf.PIC_DIR
        folder_name = str(socketid)
        save_dir = os.path.join(conf.PIC_DIR, folder_name)
        train_dir = os.path.join(save_dir, 'train')
        test_dir = os.path.join(save_dir, 'test')
        util_dir = os.path.join(save_dir, 'util')

        if not os.path.exists(os.path.join(old_save_dir, folder_name)):
            raise Exception('No training images has been provided for this job.')

        trainModel(save_dir, post_dict['socketid'])

        data['info'] = 'completed'
        response = JSONResponse(data, {}, response_mimetype(request))
        response['Content-Disposition'] = 'inline; filename=files.json'
        log_to_terminal('Finished training your model with the new categories. Now, upload some test images to test this model. ', socketid)
        return response
    except Exception as e:
        data['error'] = str(traceback.format_exc())
        log_to_terminal(str(traceback.format_exc()), socketid)
        response = JSONResponse(data, {}, response_mimetype(request))
        response['Content-Disposition'] = 'inline; filename=files.json'
        return response

def delete_equipment(request):
    if request.method == 'POST':
        post = parser.parse(request.POST.urlencode())
        e = Equipment.objects.get(pk=int(post['equip']))
        print 'vai deletar aqui'
        #e.delete()
    return HttpResponse("ok", mimetype='application/json')

	def get(self, request, **kwargs):
		arguments = parser.parse(request.GET.urlencode())

		take = arguments.get('take', 10)
		skip = arguments.get('skip', 0)
		total = skip+take
		filter_arg = dict()
		sort_arg = list()
		filter_logic = 'and'

		if(arguments.has_key('filter') and arguments['filter'].has_key('filters')):
			filter_arg = self._build_filters(arguments['filter']['filters'], filter_arg)
			filter_logic = arguments['filter']['logic'].upper()

		if(arguments.has_key('group')):
			sort_arg = self._build_sorts(arguments['group'], sort_arg)

		if(arguments.has_key('sort')):
			sort_arg = self._build_sorts(arguments['sort'], sort_arg)

		output = dict()

		try:
			filters = Q(**filter_arg)
			filters.connector = filter_logic
			items = self.model.objects.filter(filters).order_by(*sort_arg)
			if(self.distinct):
				items = items.distinct()
			self.queryset = items[skip:total]
			output = {'result':1, 'count':items.count(), 'payload':self.get_queryset()}
		except FieldError:
			output = {'result':0, 'error':'Invalid request. Tried to filter or sort using invalid field.'}

		return response_json(request, output)

    def parse(self, stream, media_type=None, parser_context=None):
        import urllib
        from querystring_parser import parser
        from django.conf import settings

        encoding = parser_context.get("encoding", settings.DEFAULT_CHARSET)
        return parser.parse(stream.read(), unquote=True, encoding=encoding)

def geocoder(request):
    
    parsed_dict = parser.parse(request.POST.urlencode())
                    
    r = Geocode(parsed_dict['addresses'])
        
    return HttpResponse(r, mimetype='application/json')

def page_report(request, report, fmt='csv', conf=None):
    get_dict = parser.parse(request.GET.urlencode())
    objs = get_queryset(request, report, get_dict)[:100]
    if objs.count()==0:
        return HttpResponse('No Data')

#    if(isinstance(objs, list)):
#        conn = DictListConnector(objs, expand_obs=True)
#    else:
#        conn = DjangoQuerySetConnector(objs)

#    if report in REPORTS:
#        cls = REPORTS[report]
#        if cls.Meta.fields:
#            conn.header = cls.Meta.fields
#        elif cls.Meta.exclude:
#            conn.header = Set(conn.header) - Set(cls.Meta.exclude)
#        elif cls.Meta.sequence:
#            conn.header = Set(cls.Meta.sequence) | Set(conn.header)

    tf = tempfile.NamedTemporaryFile()
    fn = tf.name
    fp = open(fn, "w+")
    DataProvider.WriteData(objs, fmt, fn)
    fp.close()
    response = StreamingHttpResponse(open(fn), content_type='text/csv') 
    response['Content-Disposition'] = 'attachment; filename=' + report  + '.csv'
    return response

def set_led_values(device_name):
    check_device(device_name)
    dev = devices[device_name]
    args = parser.parse(request.get_data())
    for led, value in args['led'].items():
        dev.set_pwm(int(led), int(value))
    return create_response({'result': 'ok'})

def decaf_train(request):
    post_dict = parser.parse(request.POST.urlencode())
    try:
        if 'urls' not in post_dict:
            data = {'error': 'NoFileSelected'}
        else:
            data = {'info': 'ProcessingImages'}

            # Download these images. Run Feature Extraction. Post results.
            uuid, image_path = downloadAndSaveImages(post_dict['urls'], post_dict['socketid'])

            output_path = os.path.join(image_path, 'results')
            if not os.path.exists(output_path):
                os.makedirs(output_path)
            decaf_wrapper_local(image_path, output_path, post_dict['socketid'], os.path.join(conf.PIC_URL, uuid))
            log_to_terminal('Processing Images Now', post_dict['socketid'])

        response = JSONResponse(data, {}, response_mimetype(request))
        response['Content-Disposition'] = 'inline; filename=files.json'
        return response
    except:
        data = {'result': str(traceback.format_exc())}
        response = JSONResponse(data, {}, response_mimetype(request))
        response['Content-Disposition'] = 'inline; filename=files.json'
        return response

def show_deploy(request, cluster_id):


    #get_dict = parser.parse( unicode(request.GET.urlencode()).encode("utf-8") )
    #return uncache_response(HttpResponse(json.dumps(get_dict, indent=2), content_type="text/plain"))
    #return uncache_response(HttpResponse( get_dict['password'] , content_type="text/plain"))

    context = {}
    password = None

    try:
        cluster = ClusterDefinition.objects.get( id=cluster_id )

        if cluster.encryption_checksum != '':
            try:
                get_dict = parser.parse( unicode(request.GET.urlencode()).encode("utf-8") )
                password = get_dict['password']
                cluster.decrypt(password)
            except Exception as e:
                #messages.error(request, "The password provided is wrong: %s" % e)
                messages.error(request, "The password provided is wrong")
                return render(request, "cluster/deploy.html", {})

    except ClusterDefinition.DoesNotExist, Http404:
        messages.error(request, 'Cluster does not exist')
        return render(request, "cluster/deploy.html", {})

    def get(self):
        args = parser.parse(request.query_string)
        options = {
            "start": args.get("start", 0),
            "limit": args.get("length", 10),
            "search": args.get("search", {}).get("value"),
        }

        columns = []
        for i in range(len(args["columns"])):
            columns.append(args["columns"][i])

        order = []
        for i in range(len(args["order"])):
            column_id = args["order"][i]["column"]
            order.append({"column": columns[column_id]["data"], "dir": args["order"][i]["dir"]})
        options["order"] = order

        rows, total = self.get_queryset(**options)
        data = []
        for row in rows:
            row_data = {}
            for column in columns:
                callback = getattr(self, "process_%s" % column["data"], lambda row, val: val)
                val = getattr(row, column["data"], None)
                row_data[column["data"]] = callback(row, val)
            data.append(row_data)

        return jsonify(recordsTotal=total, recordsFiltered=total, data=data)

    def parse(self, stream, media_type=None, parser_context=None):
        from querystring_parser import parser
        from django.conf import settings

        encoding = parser_context.get('encoding', settings.DEFAULT_CHARSET)
        encoded_data = stream.read().decode(encoding)
        return parser.parse(encoded_data)

def get_bookmarks(request):
    #sync the client-side bookmarks with the server side bookmarks
    #update the server-side bookmarks and return the new list
    try:        
        bookmark_dict = parser.parse(request.POST.urlencode())['bookmarks']
    except:
        bookmark_dict = {}
    try:
        #loop through the list from the client
        #if user, bm_name, and bm_state match then skip 
        #otherwise, add to the db
        for key,bookmark in bookmark_dict.items():
            try:
                Bookmark.objects.get(user=request.user, name=bookmark['name'], url_hash=bookmark['hash'])
            except:
                new_bookmark = Bookmark(user=request.user, name=bookmark['name'], url_hash=bookmark['hash'])
                new_bookmark.save()
    
        #grab all bookmarks belonging to this user 
        #serialize bookmarks into 'name', 'hash' objects and return simplejson dump 
        content = []
        bookmark_list = Bookmark.objects.filter(user=request.user)
        for bookmark in bookmark_list:
            content.append({'name': bookmark.name, 'hash': bookmark.url_hash})
        return HttpResponse(simplejson.dumps(content), mimetype="application/json", status=200)
    except:
        return HttpResponse(status=304)

def _validate_for_save(request):
    """
    Validates the HttpRequest. It uses the forms defined in forms.py to
    check all the fields and runs some additional checks. It returns
    an HttpResponse instance if request is invalid and the dictionary of clean
    date otherwise.
    """
    data = parser.parse(request.POST.urlencode())
    clean_data = {}

    # Cluster section
    cluster_f = ClusterForm(data.get("cluster", {}))
    if not cluster_f.is_valid():
        for label, msg in cluster_f.errors_list:
            messages.error(request, "Cluster %s: %s" % (label, msg))
        return _show_cluster_def(request, data)
    clean_data["cluster"] = cluster_f.clean()

    # Check that contexts belong to user or is public
    for context_field_code in ["master_context_id", "worker_context_id"]:
        c = ContextDefinition.objects.get(
            id=clean_data["cluster"][context_field_code]
        )
        if not c.public and c.owner != request.user:
            messages.error(
                request,
                "Context with id '%s' is not public and does not belong to\
 you" % (c.id)
            )
            return _show_cluster_def(request, data)
        #if c.is_encrypted:
        #    messages.error(request, "Context '%s' is encrypted!" % (c.name))
        #    return _show_cluster_def(request, data)

    # elastiq section
    elastiq_f = ElastiqForm(data.get("elastiq", {}))
    if not elastiq_f.is_valid():
        for label, msg in elastiq_f.errors_list:
            messages.error(request, "elastiq %s: %s" % (label, msg))
        return _show_cluster_def(request, data)
    clean_data["elastiq"] = elastiq_f.clean()

    # EC2 section
    ec2_f = EC2Form(data.get("ec2", {}))
    if not ec2_f.is_valid():
        for label, msg in ec2_f.errors_list:
            messages.error(request, "EC2 %s: %s" % (label, msg))
        return _show_cluster_def(request, data)
    clean_data["ec2"] = ec2_f.clean()

    # Quota section
    quota_f = QuotaForm(data.get("quota", {}))
    if not quota_f.is_valid():
        for label, msg in quota_f.errors_list:
            messages.error(request, "Quota %s: %s" % (label, msg))
        return _show_cluster_def(request, data)
    clean_data["quota"] = quota_f.clean()

    return clean_data

 def update_cart(self):
     """
     Cart update form action: update quantities, remove marked for removal items
     """
     post_dict = parser.parse(self.request.POST.urlencode())
     self.request.cart.update_quantities(post_dict["item_quantity"])
     if "remove_item" in post_dict:
         self.request.cart.remove_items(list(post_dict["remove_item"]))

def decafDemo(request):
    post_dict = parser.parse(request.POST.urlencode())
    log_to_terminal('Processing Demo Images Now', post_dict['socketid'])
    if 'src' in post_dict and post_dict['src']!='':
        file_name = basename(urlparse(post_dict['src']).path)
        redis_obj.publish(decaf_channel_name, json.dumps({'dir': DEMO_IMAGE_PATH, 'flag': '2', 'socketid': post_dict['socketid'], 'demo':'True', 'filename': file_name}))
    else:
        redis_obj.publish(decaf_channel_name, json.dumps({'dir': DEMO_IMAGE_PATH, 'flag': '2', 'socketid': post_dict['socketid']}))

def user_availability_create(request):
	#try:
	data = parser.parse(request.POST.urlencode())
	user = get_current_user(request)
	if data.get('availability'):
		availability_raw = data['availability']['']
	else:
		availability_raw = []
	availability = []
	if not isinstance(availability_raw, list):
		availability_raw = [availability_raw]
	for available_raw_item in availability_raw:
		avail_data = string.split(available_raw_item, '_')
		if avail_data[1] == 'morning':
			time_array = [16, 18, 20, 22]
		elif avail_data[1] == 'afternoon':
			time_array = [24, 26, 28, 30]
		elif avail_data[1] == 'night':
			time_array = [32, 34, 36, 38]
		elif avail_data[1] == 'late-night':
			time_array = [40, 42, 44]
		elif avail_data[1] == 'night-owl':
			time_array = [46, 48, 50]
		for time in time_array:
			availability.append({
				'day': int(avail_data[0]),
				'start_time': int(time),
				'end_time': int(time) + 2
			})

	availability_array = []
	for available_slot in availability:
		newSlot = available_slot
		newSlot['start_time'] -= user.timezone * 2
		newSlot['end_time'] -= user.timezone * 2
		if newSlot['start_time'] < 0:
			newSlot['day'] = newSlot['day'] - 1
			newSlot['start_time'] = 48 + newSlot['start_time']
		if newSlot['end_time'] < 0:
			newSlot['end_time'] = 48 + newSlot['end_time']
		if newSlot['start_time'] > 47:
			newSlot['start_time'] = newSlot['start_time'] - 48
			newSlot['day'] = newSlot['day'] + 1
		if newSlot['end_time'] > 47:
			newSlot['end_time'] = newSlot['end_time'] - 48
		if newSlot['day'] < 0:
			newSlot['day'] = 7 + newSlot['day']
		if newSlot['day'] > 6:
			newSlot['day'] = newSlot['day'] - 7
		avail_document = UserAvailability(
			day = newSlot['day'],
			start_time = newSlot['start_time'],
			end_time = newSlot['end_time']
		)
		availability_array.append(avail_document)
	user.availability = availability_array
	user.save()
	return HttpResponse(model_encode(user.availability_tz()), mimetype="application/json")

def course_list_ajax_handler(request):
    request_dict = querystring_parser.parse(request.GET.urlencode())
    draw = int(request_dict['draw'])
    start = request_dict['start']
    length = request_dict['length']
    search = request_dict.get('search', None)

    objects = Course.objects.all()

    if search and search['value']:
        objects = objects.filter(Q(name__icontains=search['value']) |
                                 Q(school__name__icontains=search['value']) |
                                 Q(department__school__name__icontains=search['value']))

    order_fields = []
    for order_index in request_dict['order']:
        order_field = None
        order = request_dict['order'][order_index]
        if order['column'] == 1:
            order_field = 'updated_at'
        elif order['column'] == 2:
            order_field = 'file_count'
        elif order['column'] == 3:
            order_field = 'thank_count'

        if order['dir'] == 'desc':
            order_field = '-' + order_field

        if order_field:
            order_fields.append(order_field)

    objects = objects.order_by(*order_fields)

    displayRecords = objects.count()

    if start > 0:
        objects = objects[start:]

    objects = objects[:length]

    row_data = [
        [
            course_json(course),
            calendar.timegm(course.updated_at.timetuple()),
            course.file_count,
            course.thank_count,
            course.school.name if course.school else course.department.school.name,
        ] for course in objects
    ]

    response_dict = {
        'draw': draw,
        'recordsTotal': Course.objects.count(),
        'recordsFiltered': displayRecords,
        'data': row_data
    }

    return HttpResponse(json.dumps(response_dict), mimetype='application/json')

def route_calculator(request):
    
    parsed_dict = parser.parse(request.POST.urlencode())
    
    p = parsed_dict['points']
    t = parsed_dict['tolerance']
    
    r = Routecalc(p,t)
    
    return HttpResponse(r, mimetype='application/json')

def demoVqa(request):
    post_dict = parser.parse(request.POST.urlencode())
    try:
        socketid = post_dict['socketid']

        if 'src' not in post_dict:
            data = {'error': 'NoImageSelected'}
        else:
            data = {'info': 'Processing'}
            result_prefix_url = post_dict['src']
            imgname = basename(urlparse(result_prefix_url).path)

            image_path = os.path.join(conf.LOCAL_DEMO_VQA_PIC_DIR, imgname)

            # folder_name = str(shortuuid.uuid())
            # For now lets use socket id
            folder_name = socketid
            save_dir = os.path.join(conf.PIC_DIR, folder_name)
            feat_folder = os.path.join(save_dir, 'results')

            # Make the new directory based on time
            if not os.path.exists(save_dir):
                os.makedirs(save_dir)
                os.makedirs(feat_folder)

            feat_path = os.path.join(feat_folder, imgname)

            print image_path
            print result_prefix_url
            log_to_terminal('Processing image...', socketid)

            # This is for running it locally ie on Godel
            vqa_wrapper_feat(image_path, socketid, result_prefix_url, feat_path)

            # This is for posting it on Redis - ie to Rosenblatt
            # classify_wrapper_redis(image_path, post_dict['socketid'], result_path)

            data = {'info': 'Completed'}

        try:
            request.META['REMOTE_ADDR']

        except:
            print str(traceback.format_exc())
            log_to_terminal(str(traceback.format_exc()), socketid)
            response = JSONResponse(data, {}, response_mimetype(request))
            response['Content-Disposition'] = 'inline; filename=files.json'
            return response

    except:
        data = {'result': str(traceback.format_exc())}
        response = JSONResponse(data, {}, response_mimetype(request))
        response['Content-Disposition'] = 'inline; filename=files.json'
    log_to_terminal(str(traceback.format_exc()), socketid)
    return response