Python Serializer.json_response函数代码示例

 def _view3(request, *args, **kwargs):
     post = request.POST
     if not post or not post.get('token'):
         _LOGGER.info('Token Required for Manager.')
         return json_response(PARAM_REQUIRED, CODE_MESSAGE.get(PARAM_REQUIRED))
     token = post.get('token')
     user_meta = {}
     try:
         my_manager = manager.canteen_get_by_token(token)
         _LOGGER.info('Token hit in db for Manager User')
         user_meta.update({'manager_model': my_manager})
         user_meta.update({"flag": CANTEEN_FLAG})
         request.user_meta = user_meta
     except ObjectDoesNotExist:
         pass
         # _LOGGER.info('Token not in db for Canteen Manager.')
         # return json_response(TOKEN_INVALID, CODE_MESSAGE.get(TOKEN_INVALID))
     if user_meta.get("flag",None) is None:
         try:
             my_manager = manager.school_get_by_token(token)
             _LOGGER.info('Token hit in db for School User')
             user_meta.update({'manager_model': my_manager})
             user_meta.update({"flag": SCHOOL_FLAG})
             request.user_meta = user_meta
         except ObjectDoesNotExist:
             _LOGGER.info('Token not in db for Manager.')
             return json_response(TOKEN_INVALID, CODE_MESSAGE.get(TOKEN_INVALID))
     return func(request, *args, **kwargs)

def sm_delete_notice(request):
    school_manager = request.user_meta.get("manager_model")
    notice_id = request.POST.get("notice_id")
    notice_model = notice.get_school_notice_by_id(notice_id)
    if school_manager != notice_model.manager:
        return json_response(AUTHORFAILED, CODE_MESSAGE.get(AUTHORFAILED))
    notice.delte_notice(notice_model)
    return json_response(OK, CODE_MESSAGE.get(OK))

def customer_custom_addr_delete(request):
    address_form = AddressDeleteForm(request.POST)
    if address_form.is_valid():
        address_dict = address_form.cleaned_data
        customer_model = request.user_meta['customer_model']
        customer.delete_custom_addr(customer_model, address_dict)
        return json_response(OK, CODE_MESSAGE.get(OK))
    else:
        return json_response(PARAM_REQUIRED, address_form.errors)

def window_dish_delete(request):
    delete_id_list_form = DeleteIdListForm(request.POST)
    if delete_id_list_form.is_valid():
        delete_id_list_dict = delete_id_list_form.cleaned_data
        delete_id_list = delete_id_list_dict['data']
        window_id = request.user_meta['window_model'].id
        dish.delete(window_id, delete_id_list)
        return json_response(OK, CODE_MESSAGE.get(OK))
    else:
        return json_response(PARAM_REQUIRED, delete_id_list_form.errors)

def window_order_update(request):
    order_update_form = WindowOrderUpdateForm(request.POST)
    if order_update_form.is_valid():
        order_update_dict = order_update_form.cleaned_data
        window_id = request.user_meta['window_model'].id
        impact = order.update_status_bywin(window_id, order_update_dict)
        if impact == 1:
            return json_response(OK, CODE_MESSAGE.get(OK))
        else:
            return json_response(DB_ERROR, CODE_MESSAGE.get(DB_ERROR))
    else:
        return json_response(PARAM_REQUIRED, order_update_form.errors)

def window_dish_update(request):
    dish_update_form = DishUpdateForm(request.POST, request.FILES)
    if dish_update_form.is_valid():
        dish_update_dict = dish_update_form.cleaned_data
        window_id = request.user_meta['window_model'].id
        impact = dish.update(window_id, dish_update_dict)
        if impact == 1:
            return json_response(OK, CODE_MESSAGE.get(OK))
        else:
            return json_response(DB_ERROR, CODE_MESSAGE.get(DB_ERROR))
    else:
        return json_response(PARAM_REQUIRED, dish_update_form.errors)

 def _view(request, *args, **kwargs):
     post = request.POST
     if not post or not post.get('token'):
         _LOGGER.info('Token Required for User')
         return json_response(PARAM_REQUIRED, CODE_MESSAGE.get(PARAM_REQUIRED))
     token = post.get('token')
     if token == TOKEN:
         # _LOGGER.info('Token is equal to Default TOKEN.')
         return func(request, *args, **kwargs)
     else:
         _LOGGER.info('Token is not equal to Default TOKEN.')
         return json_response(TOKEN_INVALID, CODE_MESSAGE.get(TOKEN_INVALID))

def window_deliver_time_update(request):
    deliver_time_updated_form = DeliverTimeUpdateForm(request.POST)
    if deliver_time_updated_form.is_valid():
        deliver_time_updated_dict = deliver_time_updated_form.cleaned_data
        window_id = request.user_meta['window_model'].id
        impact = deliver_time.update(window_id, deliver_time_updated_dict)
        if impact == 1:
            return json_response(OK, CODE_MESSAGE.get(OK))
        else:
            return json_response(DB_ERROR, CODE_MESSAGE.get(DB_ERROR))
    else:
        return json_response(PARAM_REQUIRED, deliver_time_updated_form.errors)

def window_password_update(request):
    window_password_form = PasswordUpdateForm(request.POST)
    if window_password_form.is_valid():
        window_password_dict = window_password_form.cleaned_data
        window_model = request.user_meta['window_model']
        if window_model.password == window_password_dict['old_password']:
            window.update_password(window_model, window_password_dict)
            return json_response_from_object(OK, CODE_MESSAGE.get(OK))
        else:
            return json_response(USER_PWD_ERROR, CODE_MESSAGE.get(USER_PWD_ERROR))
    else:
        return json_response(PARAM_REQUIRED, window_password_form.errors)

def window_order_display(request):
    pagination_form = PaginationForm(request.POST)
    if pagination_form.is_valid():
        pagination_dict = pagination_form.cleaned_data
        window_id = request.user_meta['window_model'].id
        order_status = pagination_dict['order_status']
        if not order_status == ORDER_STATUS[0][0]:
            order_bean_list = order.get_order_bean_list_bywin(window_id, order_status, pagination_dict)
            return json_response_from_object(OK, order_bean_list, 'orderList')
        else:
            return json_response(ORDER_STATUS_ERROR, CODE_MESSAGE.get(ORDER_STATUS_ERROR))
    else:
        return json_response(PARAM_REQUIRED, pagination_form.errors)

def window_promotion_update(request):
    promotion_update_form = PromotionUpdateForm(request.POST)
    if promotion_update_form.is_valid():
        window_model = request.user_meta['window_model']
        promotion_update_dict = promotion_update_form.cleaned_data
        impact = promotion.update(window_model.id, promotion_update_dict)
        if impact == 1:
            window.update_promotion_list(window_model)
            return json_response(OK, CODE_MESSAGE.get(OK))
        else:
            return json_response(DB_ERROR, CODE_MESSAGE.get(DB_ERROR))
    else:
        return json_response(PARAM_REQUIRED, promotion_update_form.errors)

def window_deliver_time_create(request):
    deliver_time_form = DeliverTimeForm(request.POST)
    if deliver_time_form.is_valid():
        window_model = request.user_meta['window_model']
        if window_model.deliver_time_number <= DELIVER_TIME_MAX:
            new_deliver_time = deliver_time.create(deliver_time_form, False)
            new_deliver_time.window = window_model
            deliver_time_bean = deliver_time.create(new_deliver_time)
            window.update_deliver_time_number(window_model, 1)  # update deliver_time_number of window
            return json_response_from_object(OK, deliver_time_bean)
        else:
            return json_response(DELIVER_TIME_REACH_MAX, CODE_MESSAGE.get(DELIVER_TIME_REACH_MAX))
    else:
        return json_response(PARAM_REQUIRED, deliver_time_form.errors)

def window_dish_create(request):
    dish_form = DishForm(request.POST, request.FILES)
    if dish_form.is_valid():
        window_model = request.user_meta['window_model']
        if window_model.dish_number <= DISH_MAX:
            new_dish = dish.create(dish_form, False)
            new_dish.window = window_model
            dish_bean = dish.create(new_dish)
            window.update_dish_number(window_model, 1)  # update dish_number of window
            return json_response_from_object(OK, dish_bean)
        else:
            return json_response(DISH_REACH_MAX, CODE_MESSAGE.get(DISH_REACH_MAX))
    else:
        return json_response(PARAM_REQUIRED, dish_form.errors)

def window_login(request):
    window_login_form = LoginForm(request.POST)
    if window_login_form.is_valid():
        window_login_dict = window_login_form.cleaned_data
        try:
            window_model = window.get_by_username(window_login_dict)
            if window_model.password == window_login_dict['password']:  # verify user's authority
                window_bean = window.update_token(window_model, window_login_dict)  # assign a token for user
                return json_response_from_object(OK, window_bean)
            else:
                return json_response(USER_LOGIN_FAILED, CODE_MESSAGE.get(USER_LOGIN_FAILED))
        except ObjectDoesNotExist:
            return json_response(USER_NOT_EXIST, CODE_MESSAGE.get(USER_NOT_EXIST))
    else:
        return json_response(PARAM_REQUIRED, window_login_form.errors)

def sm_modify_own_notice(request):
    change_notice_form = ChangeSNoticeForm(request.POST)
    if change_notice_form.is_valid():
        change_notice_dict= change_notice_form.cleaned_data
        school_manager = request.user_meta.get("manager_model")
        notice_id = request.POST.get("notice_id")
        already_notice = notice.get_school_notice_by_id(notice_id)
        # 只能修改自己发布的通知
        if school_manager != already_notice.manager:
            return json_response(AUTHORFAILED, CODE_MESSAGE.get(AUTHORFAILED))

        notice_bean = notice.sm_modify_notice(already_notice, change_notice_dict)
        return json_response_from_object(OK, notice_bean)
    else:
        return json_response(PARAM_REQUIRED, change_notice_form.errors)