zhuishuyun_quickapp/app/Modules/Book/Services/ChapterService.php

<?php
/**
 * Created by PhpStorm.
 * User: tandunzhao
 * Date: 2017/12/4
 * Time: 下午1:57
 */

namespace App\Modules\Book\Services;

use App\Modules\Book\Models\Book;
use App\Modules\Book\Models\Chapter;
use OSS\Core\OssException;
use OSS\OssClient;
use Redis;
use Storage;
use Log;

class ChapterService
{
    //private static $bucket = 'yueduyun';
    private static $bucket = 'zhuishuyun';

    /**
     * 获取章节内容
     * @param $bid
     * @param $chapter_id
     * @return array|bool|mixed|null|string
     */
    public static function getChapter($bid,$chapter_id){
        if(empty($bid) || empty($chapter_id))
            return false;
        //Redis::incr('book_'.$bid.'_click_count');
        //从redis获取
        try{
            $res = self::getChapterFromRedis($bid,$chapter_id);
            if($res) {
                return json_decode($res);
            }
        }catch (\Exception $e){
            Log::info($e);
        }

        //从oss获取
        try{
            $res = self::getChapterFromOss($bid,$chapter_id);
            if($res) {
                try{
                    self::saveChapterToRedis($bid,json_decode($res));
                }catch (\Exception $redis){
                    Log::info($redis);
                }
                return json_decode($res);
            }
        }catch (\Exception $e){
            Log::info($e);
        }
        $res = self::getChapterFromDb($bid,$chapter_id);

        if(empty($res)) return false;
        try{
            self::saveChapterToRedis($bid,$res);
            self::saveChapterToOss($bid,$res);
        }catch (\Exception $e){
            Log::info($e);
        }
        return $res;
    }

    /**
     * 根据cid获取章节内容
     * @param $chapter_id
     * @return mixed
     */
    public static function getChapterById($chapter_id){
        return Chapter::getChapterById($chapter_id);
    }


    /**
     * 获取目录不分页
     * @param $bid
     * @return mixed
     */
    public static function getChapterLists($bid)
    {
        $lists = Chapter::getChapterLists($bid);
        return $lists;
    }


    /**
     * 获取目录分页
     * @param $bid
     * @param int $page_size
     * @return mixed
     */
    public static function getChapterListsPage($bid,$page_size=15){
        $lists = Chapter::getChapterListsPage($bid,$page_size);
        return $lists;
    }

    /**
     * 获取章节信息没有内容
     * @param $chapter_id
     * @return mixed
     */
    public static function getChapterNameById($chapter_id,$bid)
    {
        $chapter = Chapter::getChapterNameById($chapter_id);
        if($chapter && $chapter->bid == $bid){
            return $chapter;
        }
        return false;
    }

    /**
     * 获取章节信息没有内容 不做bid的验证
     * @param $chapter_id
     * @return mixed
     */
    public static function getChapterNameByIdNoCheck($chapter_id){
        return Chapter::getChapterNameById($chapter_id);
    }


    /**
     * 获取前五章内容(推广需要)
     * @param $bid
     * @return mixed
     */

    public static function getTopFiveChapter($bid)
    {
        $res = Chapter::getTopFiveChapter($bid);
        return $res;
    }



    /**
     * 从oss获取章节内容
     * @param $chapter_id
     * @param $bid
     */

    public static function getChapterFromOss($bid, $chapter_id)
    {
        $bucket = env('OSS_BUCKET','zhuishuyun');
        $oss = self::ossObject();
        $path_format = 'book/chapters/%s/%s.json';
        $path = sprintf($path_format, $bid, $chapter_id);
        if ($oss->doesObjectExist($bucket, $path)) {
            return $oss->getObject($bucket, $path);
        }
        return null;
    }

    /**
     * 从redis获取章节内容
     * @param $chapter_id
     * @param $bid
     */

    public static function getChapterFromRedis($bid, $chapter_id)
    {
        $key = sprintf('book_chapter_%s_%s', $bid, $chapter_id);
        //Redis::connection('chapter')
        return Redis::connection('chapter')->get($key);
    }

    /**
     * 从db获取章节内容
     * @param $chapter_id
     * @param $bid
     */

    public static function getChapterFromDb($bid, $chapter_id)
    {
        $chapter = self::getChapterById($chapter_id);
        if ($chapter->bid != $bid) {
            return [];
        }
        return $chapter;
    }

    /**
     * 章节内容保存到oss
     * @param $chapter
     * @param $bid
     */
    public static function saveChapterToOss($bid, $chapter)
    {
        $bucket = env('OSS_BUCKET','zhuishuyun');
        $file = ('book/' . $bid . '_' . $chapter->id . '.json');
        Storage::put($file, json_encode($chapter));
        $path_format = 'book/chapters/%s/%s.json';
        self::ossObject()->uploadFile($bucket, sprintf($path_format, $bid, $chapter->id), storage_path('app/' . $file));
        Storage::delete($file);
    }

    /**
     * 章节内容保存到redis
     * @param $chapter
     * @param $bid
     */

    public static function saveChapterToRedis($bid, $chapter)
    {
        return Redis::connection('chapter')->setex(sprintf('book_chapter_%s_%s', $bid, $chapter->id),3600, json_encode($chapter));
    }

    /**
     * oss 对象
     * @return null|OssClient
     */

    public static function ossObject()
    {
        $accessKeyId = env('OSS_ACCESS_ID');
        $accessKeySecret = env('OSS_ACCESS_KEY');
        $endpoint = env('OSS_END_POINT');
        $ossClient = null;
        try {
            $ossClient = new OssClient($accessKeyId, $accessKeySecret, $endpoint);
        } catch (OssException $e) {
            return null;
        }
        return $ossClient;
    }

    //编辑vip章节
    public static function editVip($bid,$seq){
        return Chapter::editVip($bid,$seq);
    }

    public  static function editChapter($chapter){
        $bucket = env('OSS_BUCKET','zhuishuyun');
        $bid = $chapter->bid;
        $res_db = Chapter::where('id',$chapter->id)->update(['content'=>$chapter->content,'size'=>$chapter->size]);
        //$res_db = true;
        if(self::getChapterFromOss($bid,$chapter->id)){
            $oss = self::ossObject();
            $path_format = 'book/chapters/%s/%s.json';
            $oss->deleteObject($bucket,sprintf($path_format, $bid, $chapter->id));
        }
        self::saveChapterToOss($bid,$chapter);
        $res_redis = self::saveChapterToRedis($bid,$chapter);
        return $res_db  && $res_redis;

    }

    //章节列表和内容
    public static function getChapterPage($bid,$page_size=15){
        return Chapter::getChapterPage($bid,$page_size);
    }

    /**
     * 根据bid和顺序获取章节信息
     * @param $bid
     * @param $seq
     * @return mixed
     */
    public static function getChapterInfoByBidAndSeq($bid,$seq){
        return Chapter::where('bid',$bid)->where('sequence',$seq)->select('id','name')->first();
    }

    public static function updateSequence(int $bid,int $sequence){
        Chapter::where('bid',$bid)->where('sequence','>',$sequence)->decrement('sequence',1);
    }

    public static function updateSequenceIncr(int $bid,int $sequence){
        Chapter::where('bid',$bid)->where('sequence','>=',$sequence)->increment('sequence',1);
    }


    public static function updateChapterName($cid,$name){
        Chapter::where('id',$cid)->update(['name'=>$name]);
    }

    public static function createChapter($param){
        return Chapter::create($param);
    }

    public static function updateOne(int $id,array $param){
        if($param){
            return Chapter::where('id',$id)->update($param);
        }
        return null;
    }

    public static function splitContent($chapter_id)
    {
        $chapter = self::getChapterById($chapter_id);
        if(!$chapter || $chapter->bid <0 || $chapter->size < 4500) return [];
        $content_list = explode("\r\n",$chapter->content);
        //print_r($content_list);
        $count = 1;
        $temp_size= 0;
        $temp_content = '';
        $data = [];
        foreach ($content_list as $item){
            if($temp_size >2500){
                $count++;
                $temp_content = '';
                $temp_size = 0;
            }
            $temp_size += mb_strlen($item);
            $temp_content .= $item.'\r\n';
            $data[$count-1] = [
                'bid'=>$chapter->bid,
                'is_vip'=>$chapter->is_vip,
                'name'=>sprintf('%s(%s)',$chapter->name,$count),
                'sequence'=>$chapter->sequence+$count-1,
                'size'=>$temp_size,
                'prev_cid'=>0,
                'next_cid'=>0,
                'recent_update_at'=>$chapter->recent_update_at,
                'content'=>$temp_content,
            ];
        }

        if($data && $data[$count-1]['size'] <1500){
            $data[$count-2]['content'] = $data[$count-2]['content'].$data[$count-1]['content'];
            $data[$count-2]['size'] = $data[$count-2]['size']+$data[$count-1]['size'];
            unset($data[$count-1]);
        }

        return $data;
    }

    public static function createSplitContent($chapter_id,$data)
    {
        if(count($data) == 1){
            return ;
        }
        Chapter::where('bid',$data[0]['bid'])->where('sequence','>=',$data[0]['sequence']+1)->increment('sequence',count($data)-1);
        Chapter::where('id',$chapter_id)->update([
            'content'=>$data[0]['content'],
            'size'=>$data[0]['size']
        ]);
        foreach ($data as $kye=>$item){
            if($kye == 0) continue;
            self::createChapter($item);
        }
        self::adjustSequent($data[0]['bid'],$data[0]['sequence'],$data[0]['sequence']+count($data));

        if(self::getChapterFromOss($data[0]['bid'],$chapter_id)){
            $oss = self::ossObject();
            $bucket = env('OSS_BUCKET','zhuishuyun');
            $path_format = 'book/chapters/%s/%s.json';
            $oss->deleteObject($bucket,sprintf($path_format, $data[0]['bid'], $chapter_id));
        }
        $key = sprintf('book_chapter_%s_%s', $data[0]['bid'], $chapter_id);
        //Redis::connection('chapter')
        Redis::connection('chapter')->delete($key);

        $last = Chapter::where('bid',$data[0]['bid'])
            ->select('id','bid','name','sequence')
            ->orderBy('sequence','desc')
            ->limit(1)
            ->first();
        Book::where('id',$data[0]['bid'])->update([
            'chapter_count'=>$last->sequence,
            'last_chapter'=>$last->last_chapter,
            'last_cid'=>$last->id,
        ]);
    }

    public static function adjustSequent($bid,$start_sequence,$end_sequence){
        $chapter_list = Chapter::where('bid',$bid);
        if($start_sequence){
            $chapter_list->where('sequence','>=',$start_sequence);
        }
        if($end_sequence){
            $chapter_list->where('sequence','<=',$end_sequence);
        }
        $chapter_list->orderBy('sequence')->select('id')->get();
        $prev = 0;

        foreach ($chapter_list as $chapter){
            if($prev){
                Chapter::where('id',$chapter->id)->update(['prev_cid'=>$prev]);
                Chapter::where('id',$prev)->update(['next_cid'=>$chapter->id]);
            }
            $prev = $chapter->id;
        }
    }

}