community-manage/app/Http/Controllers/Circle/CircleController.php

<?php

/**
 * Created by PhpStorm.
 * User: Administrator
 * Date: 2019/6/5
 * Time: 15:58
 */

namespace App\Http\Controllers\Circle;

use App\Repositories\Circle\CircleArticleRepository;
use App\Repositories\Circle\CircleMemberRepository;
use App\Repositories\Circle\CircleMessageRepository;
use App\Repositories\Circle\CircleRepository;
use App\Transformers\Circle\ArticleListTransformer;
use App\Transformers\Circle\CircleMemberTransformer;
use App\Transformers\Circle\CommentTransformer;
use App\Transformers\Circle\DetailTransformer;
use App\Transformers\Circle\InterestCirclePictureTransformer;
use App\Transformers\Circle\InterestCircleTransformer;
use App\Transformers\Circle\MessageDetailTransformer;
use App\Transformers\Circle\MessageListTransformer;
use App\Transformers\Circle\PostListTransformer;
use Carbon\Carbon;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Validator;
use App\Http\Controllers\Controller;
use Illuminate\Validation\Rule;
use League\Fractal\Manager;
use League\Fractal\Pagination\IlluminatePaginatorAdapter;
use League\Fractal\Resource\Collection;
use League\Fractal\Resource\Item;

class CircleController extends Controller
{
    public function __construct(CircleRepository $circleRepository,
                                CircleArticleRepository $circleArticleRepository,
                                CircleMemberRepository $circleMemberRepository,
                                CircleMessageRepository $circleMessageRepository
    )
    {
        $this->circleRepository = $circleRepository;
        $this->circleArticleRepository = $circleArticleRepository;
        $this->circleMemberRepository = $circleMemberRepository;
        $this->circleMessageRepository = $circleMessageRepository;
    }

    /**
     * 创建圈子
     */
    public function create(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'name' => 'required|max:12',
            'image' => 'required|url',
            'notice' => 'nullable|string|max:44',
            'join_limit' => ['required', Rule::in(0, 1)],
            'limit_condition' => 'required_if:join_limit,1|integer',
        ]);
        if ($validator->fails()) {
            return $this->response->error($validator->errors()->first(), 500);
        }
        return $this->circleRepository->create($request->all());
    }

    /**
     * 修改圈子
     */
    public function update(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'id' => 'required|exists:interest_circles',
            'name' => 'required|max:12',
            'image' => 'required|url',
            'notice' => 'nullable|string|max:44',
            'join_limit' => ['required', Rule::in(0, 1)],
            'limit_condition' => 'required_if:join_limit,1|integer',
        ]);
        if ($validator->fails()) {
            return $this->response->error($validator->errors()->first(), 500);
        }
        return $this->circleRepository->update($request->all());
    }

    /**
     * 圈子列表
     */
    public function index(Request $request)
    {
        $circleList = $this->circleRepository->circleLists($request->all());
        $fractal = new Manager();
        $resource = new Collection($circleList, new InterestCircleTransformer());
        $resource->setPaginator(new IlluminatePaginatorAdapter($circleList));
        $data = $fractal->createData($resource)->toArray();
        $data['extra'] = [
            'filters' => [
                'keyword',
                'is_open'
            ],
            'columns' => [
                'id',
                'name',
                'image',
                'created_at',
                'article_count',
                'message_count',
                'view_count',
                'join_count',
                'is_recommend',
                'is_open',
            ]
        ];
        return $data;
    }


    /**
     * 圈子详情
     */
    public function detail(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'id' => 'required|exists:interest_circles'
        ]);
        if ($validator->fails()) {
            return $this->response->error($validator->errors()->first(), 500);
        }

        $circle = $this->circleRepository->detail($request->all());
        return $this->response->item($circle, new DetailTransformer());
    }

    /**
     * 圈子 推荐
     */
    public function recommend(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'id' => 'required|exists:interest_circles'
        ]);
        if ($validator->fails()) {
            return $this->response->error($validator->errors()->first(), 500);
        }
        return $this->circleRepository->circleRecommend($request->all());
    }

    /**
     * 圈子 开启/关闭
     */
    public function circleStatus(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'id' => 'required|exists:interest_circles'
        ]);
        if ($validator->fails()) {
            return $this->response->error($validator->errors()->first(), 500);
        }
        return $this->circleRepository->circleStatus($request->all());
    }

    /**
     * 相册列表
     */
    public function pictureList(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'circle_id' => 'required|integer'
        ]);
        if ($validator->fails()) {
            return $this->response->error($validator->errors()->first(), 500);
        }
        $pictureList = $this->circleRepository->pictureLists($request->all());
        $fractal = new Manager();
        $resource = new Collection($pictureList, new InterestCirclePictureTransformer());
        $resource->setPaginator(new IlluminatePaginatorAdapter($pictureList));
        $data = $fractal->createData($resource)->toArray();
        return $data;
    }

    /**
     * 删除相册图片
     */
    public function deletePicture(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'id' => 'required|exists:interest_circle_pictures'
        ]);
        if ($validator->fails()) {
            return $this->response->error($validator->errors()->first(), 500);
        }
        return $this->circleRepository->deletePicture($request->all());
    }

    /**
     * 圈子精品文章列表
     */
    public function articleList(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'circle_id' => 'required|integer'
        ]);
        if ($validator->fails()) {
            return $this->response->error($validator->errors()->first(), 500);
        }
        $articleList = $this->circleArticleRepository->lists($request->all());
        $fractal = new Manager();
        $resource = new Collection($articleList, new ArticleListTransformer());
        $resource->setPaginator(new IlluminatePaginatorAdapter($articleList));
        $data = $fractal->createData($resource)->toArray();
        $data['extra'] = [
            'filters' => [

            ],
            'columns' => [
                'id',
                'created_at',
                'uid',
                'topic',
                'content',
                'pv',
                'praise_count',
                'share_count',
                'comment_count',
                'collect_count',
                'is_recommend',
            ]
        ];
        return $data;
    }

    /**
     * 可选帖子列表
     */
    public function postList(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'circle_id' => 'required|integer'
        ]);
        if ($validator->fails()) {
            return $this->response->error($validator->errors()->first(), 500);
        }
        $productList = $this->circleArticleRepository->postList($request->all());
        $fractal = new Manager();
        $resource = new Collection($productList, new PostListTransformer($request['circle_id']));
        $resource->setPaginator(new IlluminatePaginatorAdapter($productList));
        $data = $fractal->createData($resource)->toArray();
        $data['extra'] = [
            'filters' => [
                'keyword',
                'content',
                'topic_ids',
                'category_ids',
                'is_suggest',
                'created_at',
                'type',
                'sort'
            ],
            'columns' => [
                'id',
                'created_at',
                'uid',
                'topic',
                'content',
                'image',
                'is_exists_circle',
            ]
        ];
        return $data;
    }

    /**
     * 精品文章 推荐
     */
    public function articleRecommend(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'post_id' => 'required|integer',
            'circle_id' => 'required|integer'
        ]);
        if ($validator->fails()) {
            return $this->response->error($validator->errors()->first(), 500);
        }
        return $this->circleArticleRepository->articleRecommend($request->all());
    }

    /**
     * 精品文章 加入
     */
    public function articleInsert(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'post_id' => 'required|integer',
            'circle_id' => 'required|integer'
        ]);
        if ($validator->fails()) {
            return $this->response->error($validator->errors()->first(), 500);
        }
        return $this->circleArticleRepository->articleInsert($request->all());
    }

    /**
     * 移出精品文章
     */
    public function articleRemove(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'post_id' => 'required|integer',
            'circle_id' => 'required|integer'
        ]);
        if ($validator->fails()) {
            return $this->response->error($validator->errors()->first(), 500);
        }
        return $this->circleArticleRepository->articleRemove($request->all());
    }


    /**
     * 圈子用户列表
     */
    public function memberList(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'circle_id' => 'required|integer'
        ]);
        if ($validator->fails()) {
            return $this->response->error($validator->errors()->first(), 500);
        }
        $memberList = $this->circleMemberRepository->lists($request->all());
        $fractal = new Manager();
        $resource = new Collection($memberList, new CircleMemberTransformer());
        $resource->setPaginator(new IlluminatePaginatorAdapter($memberList));
        $data = $fractal->createData($resource)->toArray();
        $data['extra'] = [
            'filters' => [
                'uid',
                'user_type'
            ],
            'columns' => [
                'id',
                'created_at',
                'uid',
                'topic',
                'content',
                'image',
                'is_exists_circle',
            ]
        ];
        return $data;
    }
    /**
     * 设置圈子黑名单
     */
    public function setCircleBlack(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'uid' => 'required|integer',
            'circle_id' => 'required|integer'
        ]);
        if ($validator->fails()) {
            return $this->response->error($validator->errors()->first(), 500);
        }
        return $this->circleMemberRepository->setUserBlack($request->all());
    }

    /**
     * 圈子留言列表
     */
    public function messageList(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'circle_id' => 'required|integer'
        ]);
        if ($validator->fails()) {
            return $this->response->error($validator->errors()->first(), 500);
        }
        $commentList = $this->circleMessageRepository->lists($request->all());
        $fractal = new Manager();
        $resource = new Collection($commentList, new MessageListTransformer());
        $resource->setPaginator(new IlluminatePaginatorAdapter($commentList));
        $data = $fractal->createData($resource)->toArray();

        $data['extra'] = [
            'filters' => [
                'uid',
                'content',
                'created_at',
            ],
            'columns' => [
                'id',
                'created_at',
                'uid',
                'username',
                'avatar',
                'circle_id',
                'circle_name',
                'content',
                'good',
                'bad',
                'comment_count',
                'is_recommend',
            ]
        ];
        return $data;
    }

    /**
     * 圈子留言详情
     */
    public function messageDetail(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'id' => 'required|exists:interest_circle_messages'
        ]);
        if ($validator->fails()) {
            return $this->response->error($validator->errors()->first(), 500);
        }

        $message = $this->circleMessageRepository->detail($request->all());
        return $this->response->item($message, new MessageDetailTransformer());
    }

    /**
     * 留言 推荐
     */
    public function messageRecommend(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'id' => 'required|integer',
            'circle_id' => 'required|integer'
        ]);
        if ($validator->fails()) {
            return $this->response->error($validator->errors()->first(), 500);
        }
        return $this->circleMessageRepository->messageRecommend($request->all());
    }

    /**
     * 删除圈子留言
     */
    public function deleteMessage(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'id' => 'required|exists:interest_circle_messages',
            'circle_id' => 'required|integer'
        ]);
        if ($validator->fails()) {
            return $this->response->error($validator->errors()->first(), 500);
        }
        return $this->circleMessageRepository->delete($request->all());
    }
    /**
     * 圈子留言评论列表
     */
    public function commentList(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'msg_id' => 'required|integer'
        ]);
        if ($validator->fails()) {
            return $this->response->error($validator->errors()->first(), 500);
        }
        $commentList = $this->circleMessageRepository->commentList($request->all());
        $fractal = new Manager();
        $resource = new Collection($commentList, new CommentTransformer());
        $resource->setPaginator(new IlluminatePaginatorAdapter($commentList));
        $data = $fractal->createData($resource)->toArray();

        $data['extra'] = [
            'filters' => [

            ],
            'columns' => [
                'id',
                'parent_id',
                'uid',
                'content',
                'created_at',
                'is_delete',
            ]
        ];
        return $data;
    }


    /**
     * 删除评论
     */
    public function commentDelete(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'id' => 'required|integer',
        ]);
        if ($validator->fails()) {
            return $this->response->error($validator->errors()->first(), 500);
        }
        return $this->circleMessageRepository->commentDelete($request->all());
    }

}