Skip to content

吕剑 / iqiyi-inject-management

Go to a project
Toggle navigation
Toggle navigation pinning
Commit a640953a a640953a329a6c122748723187645ca9fd6fe9af by 吕剑
Options

代码初始化 提交

0 parents
Inline Side-by-side
Showing 46 changed files with 4135 additions and 0 deletions
1 HELP.md
2 target/
3 !.mvn/wrapper/maven-wrapper.jar
4 !**/src/main/**/target/
5 !**/src/test/**/target/
6
7 ### STS ###
8 .apt_generated
9 .classpath
10 .factorypath
11 .project
12 .settings
13 .springBeans
14 .sts4-cache
15
16 ### IntelliJ IDEA ###
17 .idea
18 *.iws
19 *.iml
20 *.ipr
21
22 ### NetBeans ###
23 /nbproject/private/
24 /nbbuild/
25 /dist/
26 /nbdist/
27 /.nb-gradle/
28 build/
29 !**/src/main/**/build/
30 !**/src/test/**/build/
31
32 ### VS Code ###
33 .vscode/
1 <?xml version="1.0" encoding="UTF-8"?>
2 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
4 <modelVersion>4.0.0</modelVersion>
5 <parent>
6 <groupId>org.springframework.boot</groupId>
7 <artifactId>spring-boot-starter-parent</artifactId>
8 <version>2.2.10.RELEASE</version>
9 <relativePath/> <!-- lookup parent from repository -->
10 </parent>
11 <groupId>com.hui</groupId>
12 <artifactId>iqiyi</artifactId>
13 <packaging>jar</packaging>
14 <version>0.0.1-SNAPSHOT</version>
15 <name>iqiyi</name>
16 <description>Demo project for Spring Boot</description>
17 <properties>
18 <java.version>1.8</java.version>
19 <swagger.version>2.9.2</swagger.version>
20 </properties>
21 <dependencies>
22 <dependency>
23 <groupId>org.springframework.boot</groupId>
24 <artifactId>spring-boot-starter</artifactId>
25 </dependency>
26
27 <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
28 <dependency>
29 <groupId>com.alibaba</groupId>
30 <artifactId>fastjson</artifactId>
31 <version>1.2.75</version>
32 </dependency>
33
34 <dependency>
35 <groupId>io.springfox</groupId>
36 <artifactId>springfox-swagger2</artifactId>
37 <version>${swagger.version}</version>
38 </dependency>
39 <dependency>
40 <groupId>io.springfox</groupId>
41 <artifactId>springfox-swagger-ui</artifactId>
42 <version>${swagger.version}</version>
43 </dependency>
44
45 <!--freemarker模板-->
46 <dependency>
47 <groupId>org.freemarker</groupId>
48 <artifactId>freemarker</artifactId>
49 <version>2.3.31</version>
50 </dependency>
51 <!-- 模板引擎 -->
52 <dependency>
53 <groupId>org.apache.velocity</groupId>
54 <artifactId>velocity-engine-core</artifactId>
55 <version>2.0</version>
56 </dependency>
57
58
59 <!--Mysql依赖包-->
60 <dependency>
61 <groupId>mysql</groupId>
62 <artifactId>mysql-connector-java</artifactId>
63 <scope>runtime</scope>
64 </dependency>
65
66 <!--mybatis-plus依赖-->
67 <dependency>
68 <groupId>com.baomidou</groupId>
69 <artifactId>mybatis-plus-boot-starter</artifactId>
70 <version>3.0.5</version>
71 </dependency>
72
73 <dependency>
74 <groupId>com.github.pagehelper</groupId>
75 <artifactId>pagehelper-spring-boot-starter</artifactId>
76 <version>1.2.11</version>
77 </dependency>
78
79
80 <dependency>
81 <groupId>org.projectlombok</groupId>
82 <artifactId>lombok</artifactId>
83 <optional>true</optional>
84 </dependency>
85 <dependency>
86 <groupId>org.springframework.boot</groupId>
87 <artifactId>spring-boot-starter-test</artifactId>
88 <scope>test</scope>
89 </dependency>
90 <dependency>
91 <groupId>org.springframework.boot</groupId>
92 <artifactId>spring-boot-starter-web</artifactId>
93 </dependency>
94 </dependencies>
95
96 <build>
97 <finalName>iqiyi-inject-managerment</finalName>
98 <!--配置扫描Mapper-->
99 <resources>
100 <resource>
101 <directory>src/main/resources</directory>
102 </resource>
103 <resource>
104 <directory>src/main/java</directory>
105 <includes>
106 <include>**/*.xml</include>
107 </includes>
108 </resource>
109 </resources>
110 <plugins>
111 <plugin>
112 <groupId>org.springframework.boot</groupId>
113 <artifactId>spring-boot-maven-plugin</artifactId>
114 <configuration>
115 <excludes>
116 <exclude>
117 <groupId>org.projectlombok</groupId>
118 <artifactId>lombok</artifactId>
119 </exclude>
120 </excludes>
121 </configuration>
122 </plugin>
123 <plugin>
124 <groupId>org.apache.maven.plugins</groupId>
125 <artifactId>maven-surefire-plugin</artifactId>
126 <configuration>
127 <skip>true</skip>
128 </configuration>
129 </plugin>
130 <plugin>
131 <artifactId>maven-resources-plugin</artifactId>
132 <executions>
133 <execution>
134 <id>copy-resources</id>
135 <phase>package</phase>
136 <goals>
137 <goal>copy-resources</goal>
138 </goals>
139 <configuration>
140 <resources>
141 <resource>
142 <directory>src/main/resources/config</directory>
143 <includes>
144 <include>application.yml</include>
145 </includes>
146 </resource>
147 </resources>
148 <outputDirectory>${project.build.directory}/config</outputDirectory>
149 </configuration>
150 </execution>
151 </executions>
152 </plugin>
153 <!-- jar包内剔除所有配置文件 -->
154 <plugin>
155 <artifactId>maven-jar-plugin</artifactId>
156 <configuration>
157 <!--不打入jar包的文件类型或者路径-->
158 <excludes>
159 <exclude>config/**</exclude>
160 </excludes>
161 </configuration>
162 </plugin>
163 </plugins>
164
165
166 </build>
167
168 </project>
1 package com.hui;
2
3 import com.baomidou.mybatisplus.annotation.DbType;
4 import com.baomidou.mybatisplus.core.exceptions.MybatisPlusException;
5 import com.baomidou.mybatisplus.core.toolkit.StringPool;
6 import com.baomidou.mybatisplus.generator.AutoGenerator;
7 import com.baomidou.mybatisplus.generator.InjectionConfig;
8 import com.baomidou.mybatisplus.generator.config.*;
9 import com.baomidou.mybatisplus.generator.config.po.TableInfo;
10 import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
11 import com.baomidou.mybatisplus.generator.engine.FreemarkerTemplateEngine;
12 import org.apache.commons.lang3.StringUtils;
13
14 import java.util.ArrayList;
15 import java.util.List;
16 import java.util.Scanner;
17
18 // 演示例子，执行 main 方法控制台输入模块表名回车自动生成对应项目目录中
19 public class
20 CodeGenerator {
21
22 /**
23 * <p>
24 * 读取控制台内容
25 * </p>
26 */
27 public static String scanner(String tip) {
28 Scanner scanner = new Scanner(System.in);
29 StringBuilder help = new StringBuilder();
30 help.append("请输入" + tip + "：");
31 System.out.println(help.toString());
32 if (scanner.hasNext()) {
33 String ipt = scanner.next();
34 if (StringUtils.isNotBlank(ipt)) {
35 return ipt;
36 }
37 }
38 throw new MybatisPlusException("请输入正确的" + tip + "！");
39 }
40
41 public static void main(String[] args) {
42 // 代码生成器
43 AutoGenerator mpg = new AutoGenerator();
44 // 全局配置
45 GlobalConfig gc = new GlobalConfig();
46 String projectPath = System.getProperty("user.dir");
47 gc.setOutputDir(projectPath + "/src/main/java");
48 gc.setAuthor("jobob");
49 gc.setOpen(false);
50 // gc.setSwagger2(true); 实体属性 Swagger2 注解
51 mpg.setGlobalConfig(gc);
52
53 DataSourceConfig dsc = new DataSourceConfig();
54 dsc.setUrl("jdbc:mysql://139.196.37.202:3306/hyperion?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf-8");
55 dsc.setDriverName("com.mysql.cj.jdbc.Driver");
56 dsc.setUsername("root");
57 dsc.setPassword("Topdraw1qaz");
58 dsc.setDbType(DbType.MYSQL);
59 mpg.setDataSource(dsc);
60
61 // 包配置
62 PackageConfig pc = new PackageConfig();
63 pc.setModuleName(scanner("模块名"));
64 pc.setParent("com.hui");
65 mpg.setPackageInfo(pc);
66
67 // 自定义配置
68 InjectionConfig cfg = new InjectionConfig() {
69 @Override
70 public void initMap() {
71 // to do nothing
72 }
73 };
74
75 // 如果模板引擎是 freemarker
76 String templatePath = "/templates/mapper.xml.ftl";
77 // 如果模板引擎是 velocity
78 // String templatePath = "/templates/mapper.xml.vm";
79
80 // 自定义输出配置
81 List<FileOutConfig> focList = new ArrayList<>();
82 // 自定义配置会被优先输出
83 focList.add(new FileOutConfig(templatePath) {
84 @Override
85 public String outputFile(TableInfo tableInfo) {
86 // 自定义输出文件名 ， 如果你 Entity 设置了前后缀、此处注意 xml 的名称会跟着发生变化！！
87 return projectPath + "/src/main/resources/mapper/" + pc.getModuleName()
88 + "/" + tableInfo.getEntityName() + "Mapper" + StringPool.DOT_XML;
89 }
90 });
91 /*
92 cfg.setFileCreate(new IFileCreate() {
93 @Override
94 public boolean isCreate(ConfigBuilder configBuilder, FileType fileType, String filePath) {
95 // 判断自定义文件夹是否需要创建
96 checkDir("调用默认方法创建的目录，自定义目录用");
97 if (fileType == FileType.MAPPER) {
98 // 已经生成 mapper 文件判断存在，不想重新生成返回 false
99 return !new File(filePath).exists();
100 }
101 // 允许生成模板文件
102 return true;
103 }
104 });
105 */
106 cfg.setFileOutConfigList(focList);
107 mpg.setCfg(cfg);
108
109 // 配置模板
110 TemplateConfig templateConfig = new TemplateConfig();
111
112 // 配置自定义输出模板
113 //指定自定义模板路径，注意不要带上.ftl/.vm, 会根据使用的模板引擎自动识别
114 // templateConfig.setEntity("templates/entity2.java");
115 // templateConfig.setService();
116 // templateConfig.setController();
117
118 templateConfig.setXml(null);
119 mpg.setTemplate(templateConfig);
120
121 // 策略配置
122 StrategyConfig strategy = new StrategyConfig();
123 strategy.setNaming(NamingStrategy.underline_to_camel);
124 strategy.setColumnNaming(NamingStrategy.underline_to_camel);
125 strategy.setEntityLombokModel(true);
126 strategy.setRestControllerStyle(true);
127 // 公共父类
128 // 写于父类中的公共字段
129 strategy.setSuperEntityColumns("id");
130 strategy.setInclude(scanner("表名，多个英文逗号分割").split(","));
131 strategy.setControllerMappingHyphenStyle(true);
132 strategy.setTablePrefix(pc.getModuleName() + "_");
133 mpg.setStrategy(strategy);
134 mpg.setTemplateEngine(new FreemarkerTemplateEngine());
135 mpg.execute();
136 }
137
138 }
...\ No newline at end of file ...\ No newline at end of file
1 package com.hui;
2
3 import org.mybatis.spring.annotation.MapperScan;
4 import org.springframework.boot.SpringApplication;
5 import org.springframework.boot.autoconfigure.SpringBootApplication;
6
7 @SpringBootApplication
8 @MapperScan("com.hui")
9 public class IqiyiApplication {
10
11 public static void main(String[] args) {
12 SpringApplication.run(IqiyiApplication.class, args);
13 }
14
15 }
1 package com.hui.iqiyi.Util;
2
3 import lombok.Data;
4
5 /**
6 * 公共的返回类
7 */
8 @Data
9 public class ReturnBean {
10 private Integer success;//返回1成功，0失败
11 private String msg;
12
13 public static ReturnBean setSuccessInfo(String msg) {
14 return new ReturnBean(1, msg);
15 }
16
17 public static ReturnBean errorSuccessInfo(String msg) {
18 return new ReturnBean(0, msg);
19 }
20
21 public ReturnBean(Integer success, String msg) {
22 this.success = success;
23 this.msg = msg;
24 }
25 }
1 package com.hui.iqiyi.Util;
2
3 import com.github.pagehelper.PageInfo;
4 import com.hui.iqiyi.entity.Movie;
5 import com.hui.iqiyi.entity.Program;
6 import lombok.Data;
7
8 import java.util.HashMap;
9 import java.util.List;
10 import java.util.Map;
11
12 /**
13 * 返回的工具类
14 */
15 @Data
16 public class ReturnProgram<T> extends PageInfo<T> {
17 private Map<Program, List<Movie>> programMovieMap = new HashMap<>();
18
19 private List<T> list;
20 }
1 package com.hui.iqiyi.config;
2
3 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
4 import io.swagger.annotations.ApiModelProperty;
5 import lombok.Data;
6
7
8 @Data
9 public class AppPagingRequest {
10
11 @ApiModelProperty(value = "pageNo 页数 从1开始", example = "1", required = true)
12 private Integer pageNo = 1;
13
14 @ApiModelProperty(value = "pageSize 条数", example = "10", required = true)
15 private Integer pageSize = 10;
16
17 public static Page getPage(AppPagingRequest request) {
18 return new Page(request.getPageNo(), request.getPageSize());
19 }
20
21
22 }
1 /*
2 * Copyright 2019-2020 Zheng Jie
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16 package com.hui.iqiyi.config;
17
18 import io.swagger.annotations.Api;
19 import org.springframework.context.annotation.Bean;
20 import org.springframework.context.annotation.Configuration;
21 import springfox.documentation.builders.ApiInfoBuilder;
22 import springfox.documentation.builders.PathSelectors;
23 import springfox.documentation.builders.RequestHandlerSelectors;
24 import springfox.documentation.service.ApiInfo;
25 import springfox.documentation.spi.DocumentationType;
26 import springfox.documentation.spring.web.plugins.Docket;
27 import springfox.documentation.swagger2.annotations.EnableSwagger2;
28
29 /**
30 * api页面 /doc.html
31 *
32 * @author Zheng Jie
33 * @date 2018-11-23
34 */
35 @Configuration
36 @EnableSwagger2
37 //@ComponentScan(basePackages = "com.springboot.demo.controller")//配置扫描的基础包
38 class SwaggerConfiguration {
39 /**
40 * swagger2的配置文件，这里可以配置swagger2的一些基本的内容，比如扫描的包等等
41 * 在构建文档的时候 只显示添加了@Api注解的类
42 *
43 * @return
44 */
45 @Bean //作为bean纳入spring容器
46 public Docket api() {
47 return new Docket(DocumentationType.SWAGGER_2)
48 .apiInfo(apiInfo())
49 .select()
50 .paths(PathSelectors.any())
51 .apis(RequestHandlerSelectors.withClassAnnotation(Api.class))//只显示添加了@Api注解的类
52 .build();
53 }
54
55 /**
56 * 构建 api文档的详细信息函数,注意这里的注解引用的是哪个
57 *
58 * @return
59 */
60 private ApiInfo apiInfo() {
61 return new ApiInfoBuilder()
62 .title("爱奇艺注入下载服务系统")
63 .description("API接口文档，及相关接口的说明")
64 .version("1.0.0")
65 .build();
66 }
67 }
...\ No newline at end of file ...\ No newline at end of file
1 package com.hui.iqiyi.controller;
2
3
4 import com.alibaba.fastjson.JSON;
5 import com.github.pagehelper.PageHelper;
6 import com.github.pagehelper.PageInfo;
7 import com.hui.iqiyi.Util.ReturnBean;
8 import com.hui.iqiyi.entity.Content;
9 import com.hui.iqiyi.entity.Media;
10 import com.hui.iqiyi.request.ContentRequest;
11 import com.hui.iqiyi.request.MediaRequest;
12 import com.hui.iqiyi.response.ContentResponse;
13 import com.hui.iqiyi.service.IContentService;
14 import com.hui.iqiyi.service.IProgramService;
15 import io.swagger.annotations.Api;
16 import io.swagger.annotations.ApiOperation;
17 import org.springframework.web.bind.annotation.*;
18
19 import javax.annotation.Resource;
20 import java.util.Arrays;
21 import java.util.List;
22 import java.util.concurrent.LinkedBlockingQueue;
23
24 /**
25 * <p>
26 * 前端控制器
27 * </p>
28 *
29 * @author jobob
30 * @since 2021-06-03
31 */
32 @Api(tags = "查询单集列表")
33 @RestController
34 @RequestMapping("/iqiyi/content")
35 public class ContentController {
36 @Resource
37 private IContentService iContentService;
38
39 @PostMapping("/selectAllSingle")
40 @ApiOperation("查询单集")
41 @ResponseBody
42 public PageInfo<Content> selectAllSingle(ContentRequest request) {
43 PageHelper.startPage(request.getPageNo(), request.getPageSize());
44 return new PageInfo(iContentService.selectAllSingle(request, request.getId()));
45 }
46
47
48 @GetMapping("/selectAllType")
49 @ApiOperation("各类型统计数量")
50 @ResponseBody
51 public List<ContentResponse> selectAllfollow(ContentResponse contentResponse) {
52 return iContentService.selectAllType(contentResponse);
53 }
54
55
56 @GetMapping("/selectAllCont")
57 @ApiOperation("吉林片单")
58 @ResponseBody
59 public ContentResponse selectAllCont() {
60 return iContentService.selectAllCont();
61 }
62
63 }
1 package com.hui.iqiyi.controller;
2
3
4 import com.github.pagehelper.PageHelper;
5 import com.github.pagehelper.PageInfo;
6 import com.hui.iqiyi.entity.Media;
7 import com.hui.iqiyi.request.MediaRequest;
8 import com.hui.iqiyi.service.IMediaService;
9 import io.swagger.annotations.Api;
10 import io.swagger.annotations.ApiOperation;
11 import org.springframework.beans.factory.annotation.Autowired;
12 import org.springframework.web.bind.annotation.GetMapping;
13 import org.springframework.web.bind.annotation.RequestMapping;
14
15 import org.springframework.web.bind.annotation.ResponseBody;
16 import org.springframework.web.bind.annotation.RestController;
17
18 import java.util.List;
19
20 /**
21 * <p>
22 * VIEW 前端控制器
23 * </p>
24 *
25 * @author jobob
26 * @since 2021-06-03
27 */
28 @Api(tags = "爱奇艺查询")
29 @RestController
30 @RequestMapping("/iqiyi/media")
31 public class MediaController {
32
33 @Autowired
34 private IMediaService iMediaService;
35
36 @GetMapping("/selectAllIqIy")
37 @ApiOperation("查询全部剧集信息")
38 @ResponseBody
39 public PageInfo<Media> selectAllIqIy(MediaRequest request) {
40 PageHelper.startPage(request.getPageNo(), request.getPageSize());
41 return new PageInfo(iMediaService.selectAllIqIyList(request));
42 }
43
44
45 @GetMapping("/selectAllfollow")
46 @ApiOperation("查询关注平台的信息")
47 @ResponseBody
48 public List<Media> selectAllfollow(Long info) {
49 MediaRequest mediaRequest = new MediaRequest();
50 mediaRequest.setPlatformInfo(info);
51 return iMediaService.selectAllfollow(mediaRequest);
52 }
53
54 }
1 package com.hui.iqiyi.controller;
2
3
4 import com.github.pagehelper.PageHelper;
5 import com.github.pagehelper.PageInfo;
6 import com.hui.iqiyi.entity.Content;
7 import com.hui.iqiyi.entity.Movie;
8 import com.hui.iqiyi.request.ContentRequest;
9 import com.hui.iqiyi.request.ProRequest;
10 import com.hui.iqiyi.response.MovieResponse;
11 import com.hui.iqiyi.response.ProgramSyResponse;
12 import com.hui.iqiyi.service.IMovieService;
13 import io.swagger.annotations.Api;
14 import io.swagger.annotations.ApiOperation;
15 import org.springframework.beans.factory.annotation.Autowired;
16 import org.springframework.web.bind.annotation.*;
17
18 import java.util.List;
19 import java.util.Map;
20
21 /**
22 * <p>
23 * 前端控制器
24 * </p>
25 *
26 * @author jobob
27 * @since 2021-06-03
28 */
29 @Api(tags = "查询总下载")
30 @RestController
31 @RequestMapping("/iqiyi/movie")
32 public class MovieController {
33
34 @Autowired
35 private IMovieService iMovieService;
36
37 @GetMapping("/selectAllPopulation")
38 @ApiOperation("查询总下载")
39 @ResponseBody
40 public List<Movie> selectAllPopulation(Movie Movie) {
41 return iMovieService.selectAllPopulation(Movie);
42 }
43
44
45 @GetMapping("/selectAllSevenXz")
46 @ApiOperation("近七日同步情况")
47 @ResponseBody
48 public List<MovieResponse> selectAllSeven(ProRequest proRequest) {
49 return iMovieService.selectAllSevenxz(proRequest);
50 }
51
52 }
1 package com.hui.iqiyi.controller;
2
3
4 import com.alibaba.fastjson.JSON;
5 import com.github.pagehelper.PageHelper;
6 import com.github.pagehelper.PageInfo;
7 import com.hui.iqiyi.Util.ReturnBean;
8 import com.hui.iqiyi.entity.Content;
9 import com.hui.iqiyi.entity.Program;
10 import com.hui.iqiyi.request.ByIdsRequest;
11 import com.hui.iqiyi.request.ContentRequest;
12 import com.hui.iqiyi.request.ProRequest;
13 import com.hui.iqiyi.request.ProgramRequest;
14 import com.hui.iqiyi.response.ContentResponse;
15 import com.hui.iqiyi.response.ProgramResponse;
16 import com.hui.iqiyi.response.ProgramSyResponse;
17 import com.hui.iqiyi.service.IProgramService;
18 import com.sun.org.apache.bcel.internal.generic.RETURN;
19 import io.swagger.annotations.Api;
20 import io.swagger.annotations.ApiOperation;
21 import org.springframework.beans.factory.annotation.Autowired;
22 import org.springframework.beans.factory.annotation.Qualifier;
23 import org.springframework.web.bind.annotation.*;
24
25 import javax.annotation.Resource;
26 import java.util.List;
27
28 /**
29 * <p>
30 * 前端控制器
31 * </p>
32 *
33 * @author jobob
34 * @since 2021-06-03
35 */
36 @Api(tags = "添加关注")
37 @RestController
38 @RequestMapping("/iqiyi/program")
39 public class ProgramController {
40
41 @Resource
42 private IProgramService iProgramService;
43
44 @PostMapping("/addFollow")
45 @ApiOperation("添加关注")
46 public ReturnBean addFollow(@RequestBody List<ByIdsRequest> requests) {
47 return iProgramService.updateByProgramIds(requests);
48 }
49
50
51 @PostMapping("/selectFollow")
52 @ApiOperation("查看关注")
53 public Object selectProMov(@RequestBody String platFormInfo, int PageNo, int PageSize) {
54 return iProgramService.selectProMov(new Program().setPlatformInfo(platFormInfo), PageNo, PageSize);
55 }
56
57
58 @GetMapping("/selectAllSingle")
59 @ApiOperation("查询单集")
60 @ResponseBody
61 public PageInfo<ProgramResponse> selectAllSingle(ProgramRequest request) {
62 PageHelper.startPage(request.getPageNo(), request.getPageSize());
63 return new PageInfo(iProgramService.selectProgramDloadList(request));
64 }
65
66
67 @GetMapping("/selectAllSeven")
68 @ApiOperation("近七日下载情况")
69 @ResponseBody
70 public List<ProgramSyResponse> selectAllSeven(ProRequest proRequest) {
71 return iProgramService.selectAllSeven(proRequest);
72 }
73
74
75 @GetMapping("/selectAllProgramCount")
76 @ApiOperation("关注平台数据")
77 @ResponseBody
78 public ProgramSyResponse selectAllProgramCount() {
79 return iProgramService.selectAllProgramCount();
80 }
81
82
83 }
1 package com.hui.iqiyi.entity;
2
3 import com.baomidou.mybatisplus.annotation.TableName;
4
5 import java.time.LocalDateTime;
6 import java.io.Serializable;
7 import java.util.List;
8
9 import lombok.Data;
10 import lombok.EqualsAndHashCode;
11 import lombok.experimental.Accessors;
12
13 /**
14 * <p>
15 *
16 * </p>
17 *
18 * @author jobob
19 * @since 2021-06-03
20 */
21 @Data
22 @EqualsAndHashCode(callSuper = false)
23 @Accessors(chain = true)
24 @TableName("iqiyi_content")
25 public class Content implements Serializable {
26
27 private static final long serialVersionUID = 1L;
28
29 private Long id;
30
31 /**
32 * 外部id,爱奇艺的id
33 */
34 private Long externalId;
35
36 /**
37 * 类型
38 */
39 private String elementType;
40
41 /**
42 * 全局内容标识
43 */
44 private String contentId;
45
46 /**
47 * 节目名称
48 */
49 private String name;
50
51 /**
52 * 上映年份（YYYY）
53 */
54 private String year;
55
56 /**
57 * 首播日期（YYYYMMDD）
58 */
59 private String publishTime;
60
61 /**
62 * 节目描述
63 */
64 private String desc;
65
66 /**
67 * 0：失效；1：生效
68 */
69 private Integer status;
70
71 /**
72 * 关联标签
73 */
74 private String tags;
75
76 /**
77 * 是否独播 1：是；其他：否
78 */
79 private Integer excl;
80
81 /**
82 * 专辑类型 1：来源专辑；0：普通专辑
83 */
84 private Integer stype;
85
86 /**
87 * 一句话看点
88 */
89 private String focus;
90
91 /**
92 * 封面图，使用时需要拼接尺寸，结合imgPod字段能使用
93 */
94 private String picUrl;
95
96 /**
97 * 封面图片是否支持按需生产 0：不支持；1：支持
98 */
99 private Integer imgPod;
100
101 /**
102 * 所属频道ID
103 */
104 private Long cid;
105
106 /**
107 * 频道名称
108 */
109 private String cname;
110
111 /**
112 * 人物信息（JSON）
113 */
114 private String persons;
115
116 /**
117 * 作曲
118 */
119 private String composers;
120
121 /**
122 * 主持人
123 */
124 private String hosters;
125
126 /**
127 * 配音
128 */
129 private String dubbers;
130
131 /**
132 * 制片人
133 */
134 private String makers;
135
136 /**
137 * 明星
138 */
139 private String stars;
140
141 /**
142 * 出品人
143 */
144 private String producers;
145
146 /**
147 * 作词
148 */
149 private String songWriters;
150
151 /**
152 * 嘉宾
153 */
154 private String guesters;
155
156 /**
157 * 编剧
158 */
159 private String writers;
160
161 /**
162 * 导演
163 */
164 private String directors;
165
166 /**
167 * 主演（JSONArray）character：角色名称；name：演员名称；id：演员id
168 */
169 private String mainActors;
170
171 /**
172 * 演员（JSONArray）character：角色名称；name：演员名称；id：演员id
173 */
174 private String actors;
175
176 /**
177 * 短标题
178 */
179 private String sname;
180
181 /**
182 * 电视剧等多剧集的视频总数量
183 */
184 private Integer total;
185
186 /**
187 * 专辑已有视频的最大集数，不严格等于已上线的视频数量
188 */
189 private Integer currCount;
190
191 /**
192 * 是否收费
193 */
194 private Integer isCharge;
195
196 /**
197 * VIP信息节点（JSON）
198 */
199 private String vipInfo;
200
201 /**
202 * 是否会员节目 0：非会员；1：会员
203 */
204 private Integer isVip;
205
206 /**
207 * 是否点播节目 0：非点播；1：点播
208 */
209 private Integer isTvod;
210
211 /**
212 * 是否点播券节目 0：非点播券；1：点播券
213 */
214 private Integer isCoupon;
215
216 /**
217 * 是否点播套餐节目 0：非点播套餐；1：点播套餐
218 */
219 private Integer isPkg;
220
221 /**
222 * 点播节目原价，仅在is_tvod为1时才有这个字段，单位为分
223 */
224 private Integer orgPrc;
225
226 /**
227 * 有效期，仅在is_tvod为1时才有这个字段，24h、30d
228 */
229 private String validTime;
230
231 /**
232 * 是否支持是看 1：支持；0：不支持
233 */
234 private Integer supportProb;
235
236 /**
237 * 试看时长，单位毫秒
238 */
239 private Integer probDuration;
240
241 /**
242 * 国家地区，多个地区以英文逗号分隔
243 */
244 private String country;
245
246 /**
247 * 语言，多个语言以英文逗号分隔
248 */
249 private String language;
250
251 /**
252 * 索引名称
253 */
254 private String searchName;
255
256 /**
257 * 用户评分
258 */
259 private String score;
260
261 /**
262 * 同步标识 0：未进行同步，1：同步成功，-1： 同步失败
263 */
264 private Integer syncStatus;
265
266 /**
267 * 同步平台,分割
268 */
269 private String platformInfo;
270
271 /**
272 * 创建时间
273 */
274 private LocalDateTime createTime;
275
276 /**
277 * 更新时间
278 */
279 private LocalDateTime updateTime;
280
281 /**
282 * 扩展字段
283 */
284 private List<Long> ContentIdList;
285 }
1 package com.hui.iqiyi.entity;
2
3 import com.baomidou.mybatisplus.annotation.TableName;
4
5 import java.time.LocalDateTime;
6 import java.io.Serializable;
7
8 import lombok.Data;
9 import lombok.EqualsAndHashCode;
10 import lombok.experimental.Accessors;
11
12 /**
13 * <p>
14 * VIEW
15 * </p>
16 *
17 * @author jobob
18 * @since 2021-06-03
19 */
20 @Data
21 @EqualsAndHashCode(callSuper = false)
22 @Accessors(chain = true)
23 @TableName("iqiyi_media")
24 public class Media implements Serializable {
25
26 private static final long serialVersionUID = 1L;
27
28 private Long id;
29
30 private String contentId;
31
32 private Long type;
33
34 private String name;
35
36 private String year;
37
38 private String publishTime;
39
40 private Integer status;
41
42 private String tags;
43
44 private Integer excl;
45
46 private String focus;
47
48 private String picUrl;
49
50 private Integer imgPod;
51
52 private Long cid;
53
54 private String cname;
55
56 private String composers;
57
58 private String hosters;
59
60 private String dubbers;
61
62 private String makers;
63
64 private String stars;
65
66 private String producers;
67
68 private String songWriters;
69
70 private String guesters;
71
72 private String writers;
73
74 private String directors;
75
76 private String actors;
77
78 private String sname;
79
80 private Integer isCharge;
81
82 private String vipInfo;
83
84 private Integer isVip;
85
86 private Integer isTvod;
87
88 private Integer isCoupon;
89
90 private Integer isPkg;
91
92 private Integer orgPrc;
93
94 private String validTime;
95
96 private Integer supportProb;
97
98 private String country;
99
100 private String language;
101
102 private String searchName;
103
104 private String score;
105
106 private Integer syncStatus;
107
108 private String desc;
109
110 private Long stype;
111
112 private String persons;
113
114 private Long total;
115
116 private Long currCount;
117
118 private Integer probDuration;
119
120 private LocalDateTime createTime;
121
122 private LocalDateTime updateTime;
123
124 private String beginTime;
125 private String EndTime;
126
127 private Integer platformInfo;
128
129 /**
130 * 标识下载状态
131 */
132 private String downloadStatus;
133 }
1 package com.hui.iqiyi.entity;
2
3 import com.baomidou.mybatisplus.annotation.TableName;
4
5 import java.time.LocalDateTime;
6 import java.io.Serializable;
7 import java.util.List;
8
9 import lombok.Data;
10 import lombok.EqualsAndHashCode;
11 import lombok.experimental.Accessors;
12
13 /**
14 * <p>
15 *
16 * </p>
17 *
18 * @author jobob
19 * @since 2021-06-03
20 */
21 @Data
22 @EqualsAndHashCode(callSuper = false)
23 @Accessors(chain = true)
24 @TableName("iqiyi_movie")
25 public class Movie implements Serializable {
26
27 private static final long serialVersionUID = 1L;
28
29 /**
30 * 码流id
31 */
32 private String vid;
33
34 /**
35 * 类型
36 */
37 private String elementType;
38
39 /**
40 * program对象的父节点series对象
41 */
42 private String parentId;
43
44 /**
45 * 内部关联关系id,iqiyi_program表id
46 */
47 private Long iqiyiProgramId;
48
49 /**
50 * tar包下载地址
51 */
52 private String url;
53
54 /**
55 * tar包大小(单位: Byte)
56 */
57 private Long fileSize;
58
59 /**
60 * 码流时长
61 */
62 private Integer duration;
63
64 /**
65 * 清晰度：1080P、720P等
66 */
67 private String bitrate;
68
69 /**
70 * 0：失效；1：生效
71 */
72 private Integer status;
73
74 /**
75 * 本地保存的地址
76 */
77 private String localPath;
78
79 /**
80 * 本地保存ftp的地址
81 */
82 private String localFtpPath;
83
84 /**
85 * 本地状态：0 未下载（需要重新下载）;10 下载中;-100 下载失败;100 下载成功;200 成功回调
86 */
87 private Integer localStatus;
88
89 /**
90 * md5计算
91 */
92 private String md5;
93
94 /**
95 * 本地下载的文件大小
96 */
97 private Long localFileSize;
98
99 /**
100 * 下载重试次数
101 */
102 private Integer retryTimes;
103
104 /**
105 * 下载优先级
106 */
107 private Integer priority;
108
109 /**
110 * 下载错误描述
111 */
112 private String errorDescription;
113
114 /**
115 * 创建时间
116 */
117 private LocalDateTime createTime;
118
119 /**
120 * 更新时间
121 */
122 private LocalDateTime updateTime;
123
124 private Long number;
125
126 private Long capacity;
127
128 }
1 package com.hui.iqiyi.entity;
2
3 import com.baomidou.mybatisplus.annotation.TableName;
4
5 import java.time.LocalDateTime;
6 import java.io.Serializable;
7 import java.util.ArrayList;
8 import java.util.List;
9
10 import lombok.Data;
11 import lombok.EqualsAndHashCode;
12 import lombok.experimental.Accessors;
13
14 /**
15 * <p>
16 *
17 * </p>
18 *
19 * @author jobob
20 * @since 2021-06-03
21 */
22 @Data
23 @EqualsAndHashCode(callSuper = false)
24 @Accessors(chain = true)
25 @TableName("iqiyi_program")
26 public class Program implements Serializable {
27
28 private static final long serialVersionUID = 1L;
29
30 private Long id;
31 /**
32 * 外部id,爱奇艺的id
33 */
34 private Long externalId;
35
36 /**
37 * 全局内容标识
38 */
39 private String contentId;
40
41 /**
42 * 类型
43 */
44 private String elementType;
45
46 /**
47 * program对象的父节点series对象
48 */
49 private String parentId;
50
51 /**
52 * 内部关联关系id,iqiyi_content表id
53 */
54 private Long iqiyiContentId;
55
56 /**
57 * 区分单视频和剧集
58 */
59 private Integer seriesFlag;
60
61 /**
62 * 节目名称
63 */
64 private String name;
65
66 /**
67 * 国家地区。多个地区以英文逗号分隔
68 */
69 private String country;
70
71 /**
72 * 语言。多个语言以英文逗号分隔
73 */
74 private String language;
75
76 /**
77 * 上映年份（YYYY）
78 */
79 private String year;
80
81 /**
82 * 首播日期（YYYYMMDD）
83 */
84 private String publishTime;
85
86 /**
87 * 节目描述
88 */
89 //private String desc;
90
91 /**
92 * 0：失效；1：生效
93 */
94 private Integer status;
95
96 /**
97 * 关联标签
98 */
99 private String tags;
100
101 /**
102 * 一句话看点
103 */
104 private String focus;
105
106 /**
107 * 播放时长（单位为分钟）
108 */
109 private Integer length;
110
111 /**
112 * 封面图，使用时需要拼接尺寸，结合imgPod字段能使用
113 */
114 private String picUrl;
115
116 /**
117 * 封面图片是否支持按需生产 0：不支持；1：支持
118 */
119 private Integer imgPod;
120
121 /**
122 * 所属频道ID
123 */
124 private Integer cid;
125
126 /**
127 * 频道名称
128 */
129 private String cname;
130
131 /**
132 * 是否独播 1：是；其他：否
133 */
134 private Integer excl;
135
136 /**
137 * 是否3D：1：是，0：否
138 */
139 private Integer type3d;
140
141 /**
142 * 视频内容类型，枚举参考附录3.2、内容类型
143 */
144 private Integer contentType;
145
146 /**
147 * 人物信息（JSON）
148 */
149 private String persons;
150
151 /**
152 * 作曲
153 */
154 private String composers;
155
156 /**
157 * 主持人
158 */
159 private String hosters;
160
161 /**
162 * 配音
163 */
164 private String dubbers;
165
166 /**
167 * 制片人
168 */
169 private String makers;
170
171 /**
172 * 明星
173 */
174 private String stars;
175
176 /**
177 * 出品人
178 */
179 private String producers;
180
181 /**
182 * 作词
183 */
184 private String songWriters;
185
186 /**
187 * 嘉宾
188 */
189 private String guesters;
190
191 /**
192 * 编剧
193 */
194 private String writers;
195
196 /**
197 * 导演
198 */
199 private String directors;
200
201 /**
202 * 主演（JSONArray）character：角色名称；name：演员名称；id：演员id
203 */
204 private String mainActors;
205
206 /**
207 * 演员（JSONArray）character：角色名称；name：演员名称；id：演员id
208 */
209 private String actors;
210
211 /**
212 * 短标题
213 */
214 private String sname;
215
216 /**
217 * 是否收费
218 */
219 private Integer isCharge;
220
221 /**
222 * VIP信息节点（JSON）
223 */
224 private String vipInfo;
225
226 /**
227 * 是否会员节目 0：非会员；1：会员
228 */
229 private Integer isVip;
230
231 /**
232 * 是否点播节目 0：非点播；1：点播
233 */
234 private Integer isTvod;
235
236 /**
237 * 是否点播券节目 0：非点播券；1：点播券
238 */
239 private Integer isCoupon;
240
241 /**
242 * 是否点播套餐节目 0：非点播套餐；1：点播套餐
243 */
244 private Integer isPkg;
245
246 /**
247 * 点播节目原价，仅在is_tvod为1时才有这个字段，单位为分
248 */
249 private Integer orgPrc;
250
251 /**
252 * 有效期，仅在is_tvod为1时才有这个字段，24h、30d
253 */
254 private String validTime;
255
256 /**
257 * 是否支持试看 1：支持；0：不支持
258 */
259 private Integer supportProb;
260
261 /**
262 * 试看时长，单位毫秒
263 */
264 private Integer probDuration;
265
266 /**
267 * 索引名称
268 */
269 private String searchName;
270
271 /**
272 * 排序辅助字段
273 */
274 private Integer multiOrder;
275
276 /**
277 * 当前集数
278 */
279 private Integer volumnCount;
280
281 /**
282 * 用户评分
283 */
284 private String score;
285
286 /**
287 * 同步标识 0：未进行同步，1：同步成功，-1： 同步失败
288 */
289 private Integer syncStatus;
290
291 /**
292 * 同步平台,分割
293 */
294 private String platformInfo;
295
296 /**
297 * 码流信息同步标识：0：未进行同步，1：同步成功，-1： 同步失败
298 */
299 private Integer fileStatus;
300
301 /**
302 * 创建时间
303 */
304 private LocalDateTime createTime;
305
306 /**
307 * 更新时间
308 */
309 private LocalDateTime updateTime;
310 }
1 package com.hui.iqiyi.mapper;
2
3 import com.hui.iqiyi.entity.Content;
4 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
5 import com.hui.iqiyi.entity.Media;
6 import com.hui.iqiyi.request.ContentRequest;
7 import com.hui.iqiyi.request.MediaRequest;
8 import com.hui.iqiyi.response.ContentResponse;
9
10 import java.util.List;
11
12 /**
13 * <p>
14 * Mapper 接口
15 * </p>
16 *
17 * @author jobob
18 * @since 2021-06-03
19 */
20 public interface ContentMapper extends BaseMapper<Content> {
21
22 /**
23 * 修改剧头表的公共方法
24 *
25 * @param content
26 * @return
27 */
28 int updateContent(Content content);
29
30 /**
31 * 查询单集
32 *
33 * @param request
34 * @param id
35 * @return
36 */
37 List<Content> selectAllSingle(ContentRequest request, Long id);
38
39 /**
40 * 各类型统计数量
41 *
42 * @param contentResponse
43 * @return
44 */
45 List<ContentResponse> selectAllType(ContentResponse contentResponse);
46
47
48 /**
49 * 吉林单片
50 *
51 * @param
52 * @return
53 */
54 List<Integer> selectAllCont();
55
56
57 }
1 package com.hui.iqiyi.mapper;
2
3 import com.baomidou.mybatisplus.core.metadata.IPage;
4 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
5 import com.hui.iqiyi.entity.Media;
6 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
7 import com.hui.iqiyi.request.MediaRequest;
8 import org.apache.ibatis.annotations.Mapper;
9 import org.springframework.stereotype.Repository;
10
11 import java.util.List;
12
13 /**
14 * <p>
15 * VIEW Mapper 接口
16 * </p>
17 *
18 * @author jobob
19 * @since 2021-06-03
20 */
21 @Repository
22 @Mapper
23 public interface MediaMapper extends BaseMapper<Media> {
24 /**
25 * 查询所有剧集
26 *
27 * @param iqiyiContent
28 * @return
29 */
30
31 List<Media> selectAllIqIy(MediaRequest iqiyiContent);
32
33
34 /**
35 * 查询平台所关注的信息
36 *
37 * @param info
38 * @return
39 */
40
41 List<Media> selectAllfollow(MediaRequest info);
42
43 }
1 package com.hui.iqiyi.mapper;
2
3 import com.hui.iqiyi.entity.Movie;
4 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
5 import com.hui.iqiyi.request.ProRequest;
6 import com.hui.iqiyi.response.MovieResponse;
7 import org.apache.ibatis.annotations.Mapper;
8 import org.apache.ibatis.annotations.Param;
9 import org.springframework.stereotype.Repository;
10
11 import java.util.List;
12
13 /**
14 * <p>
15 * Mapper 电影表
16 * </p>
17 *
18 * @author jobob
19 * @since 2021-06-03
20 */
21 @Repository
22 @Mapper
23 public interface MovieMapper extends BaseMapper<Movie> {
24 /**
25 * 修改优先级分开写，因为需要关联更新
26 *
27 * @return
28 */
29 int updateMoviePriority(Movie movie);
30
31
32 //查询总体下载情况
33
34 List<Movie> selectAllPopulation(Movie movie);
35
36
37 /**
38 * 近七日同步
39 *
40 * @return
41 */
42 List<MovieResponse> selectAllSevenxz(@Param("proRequest") ProRequest proRequest);
43
44
45 }
1 package com.hui.iqiyi.mapper;
2
3 import com.hui.iqiyi.entity.Program;
4 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
5 import com.hui.iqiyi.request.ByIdsRequest;
6 import com.hui.iqiyi.request.ProRequest;
7 import com.hui.iqiyi.request.ProgramRequest;
8 import com.hui.iqiyi.response.*;
9 import org.apache.ibatis.annotations.Param;
10 import org.springframework.context.annotation.Primary;
11 import sun.rmi.runtime.Log;
12
13 import java.util.List;
14
15 /**
16 * <p>
17 * Mapper 接口
18 * </p>
19 *
20 * @author jobob
21 * @since 2021-06-03
22 */
23 public interface ProgramMapper extends BaseMapper<Program> {
24
25
26 /**
27 * 根据 给电影添加关注
28 */
29
30 int updateFilm(Long id);
31
32 /**
33 * 根据 id给
34 */
35 int updatePla(Long id);
36
37 /**
38 *
39 */
40 int updateTeleplay(Long id);
41
42 /**
43 * 获取每一集的下载状态
44 *
45 * @return
46 */
47 List<ProgramRequest> selectDownload(ProgramRequest program);
48
49 /**
50 * 返回Program信息
51 */
52 List<ProgramRequest> selectProgramList(ProgramRequest program);
53
54 /**
55 * 返回Program信息,连带着下载状态
56 */
57 List<ProgramResponse> selectProgramDloadList(ProgramRequest program);
58
59
60 /**
61 * 近七日下载
62 *
63 * @return
64 */
65 List<ProgramSyResponse> selectAllSeven(@Param("proRequest") ProRequest proRequest);
66
67
68 /**
69 * 关注平台数据
70 *
71 * @return
72 */
73 List<ProgramQBRequest> selectAllProgramCount();
74
75
76 }
1 package com.hui.iqiyi.request;
2
3 import io.swagger.annotations.ApiModelProperty;
4 import lombok.Data;
5
6 import java.util.List;
7
8 @Data
9 public class ByIdsRequest {
10 @ApiModelProperty(value = "Id", required = true)
11 private Long id;
12
13 @ApiModelProperty(value = "type", required = true)
14 private Integer type;
15 }
1 package com.hui.iqiyi.request;
2
3 import com.hui.iqiyi.config.AppPagingRequest;
4 import lombok.Data;
5
6 import java.time.LocalDateTime;
7 import java.util.List;
8
9 @Data
10 public class ContentRequest extends AppPagingRequest {
11
12
13 private Long id;
14
15 /**
16 * 外部id,爱奇艺的id
17 */
18 private Long externalId;
19
20 /**
21 * 类型
22 */
23 private String elementType;
24
25 /**
26 * 全局内容标识
27 */
28 private String contentId;
29
30 /**
31 * 节目名称
32 */
33 private String name;
34
35
36 /**
37 * 上映年份（YYYY）
38 */
39 private String year;
40
41 /**
42 * 首播日期（YYYYMMDD）
43 */
44 private String publishTime;
45
46 /**
47 * 节目描述
48 */
49 private String desc;
50
51 /**
52 * 0：失效；1：生效
53 */
54 private Integer status;
55
56 /**
57 * 关联标签
58 */
59 private String tags;
60
61 /**
62 * 是否独播 1：是；其他：否
63 */
64 private Integer excl;
65
66 /**
67 * 专辑类型 1：来源专辑；0：普通专辑
68 */
69 private Integer stype;
70
71 /**
72 * 一句话看点
73 */
74 private String focus;
75
76 /**
77 * 封面图，使用时需要拼接尺寸，结合imgPod字段能使用
78 */
79 private String picUrl;
80
81 /**
82 * 封面图片是否支持按需生产 0：不支持；1：支持
83 */
84 private Integer imgPod;
85
86 /**
87 * 所属频道ID
88 */
89 private Long cid;
90
91 /**
92 * 频道名称
93 */
94 private String cname;
95
96 /**
97 * 人物信息（JSON）
98 */
99 private String persons;
100
101 /**
102 * 作曲
103 */
104 private String composers;
105
106 /**
107 * 主持人
108 */
109 private String hosters;
110
111 /**
112 * 配音
113 */
114 private String dubbers;
115
116 /**
117 * 制片人
118 */
119 private String makers;
120
121 /**
122 * 明星
123 */
124 private String stars;
125
126 /**
127 * 出品人
128 */
129 private String producers;
130
131 /**
132 * 作词
133 */
134 private String songWriters;
135
136 /**
137 * 嘉宾
138 */
139 private String guesters;
140
141 /**
142 * 编剧
143 */
144 private String writers;
145
146 /**
147 * 导演
148 */
149 private String directors;
150
151 /**
152 * 主演（JSONArray）character：角色名称；name：演员名称；id：演员id
153 */
154 private String mainActors;
155
156 /**
157 * 演员（JSONArray）character：角色名称；name：演员名称；id：演员id
158 */
159 private String actors;
160
161 /**
162 * 短标题
163 */
164 private String sname;
165
166 /**
167 * 电视剧等多剧集的视频总数量
168 */
169 private Integer total;
170
171 /**
172 * 专辑已有视频的最大集数，不严格等于已上线的视频数量
173 */
174 private Integer currCount;
175
176 /**
177 * 是否收费
178 */
179 private Integer isCharge;
180
181 /**
182 * VIP信息节点（JSON）
183 */
184 private String vipInfo;
185
186 /**
187 * 是否会员节目 0：非会员；1：会员
188 */
189 private Integer isVip;
190
191 /**
192 * 是否点播节目 0：非点播；1：点播
193 */
194 private Integer isTvod;
195
196 /**
197 * 是否点播券节目 0：非点播券；1：点播券
198 */
199 private Integer isCoupon;
200
201 /**
202 * 是否点播套餐节目 0：非点播套餐；1：点播套餐
203 */
204 private Integer isPkg;
205
206 /**
207 * 点播节目原价，仅在is_tvod为1时才有这个字段，单位为分
208 */
209 private Integer orgPrc;
210
211 /**
212 * 有效期，仅在is_tvod为1时才有这个字段，24h、30d
213 */
214 private String validTime;
215
216 /**
217 * 是否支持是看 1：支持；0：不支持
218 */
219 private Integer supportProb;
220
221 /**
222 * 试看时长，单位毫秒
223 */
224 private Integer probDuration;
225
226 /**
227 * 国家地区，多个地区以英文逗号分隔
228 */
229 private String country;
230
231 /**
232 * 语言，多个语言以英文逗号分隔
233 */
234 private String language;
235
236 /**
237 * 索引名称
238 */
239 private String searchName;
240
241 /**
242 * 用户评分
243 */
244 private String score;
245
246 /**
247 * 同步标识 0：未进行同步，1：同步成功，-1： 同步失败
248 */
249 private Integer syncStatus;
250
251 /**
252 * 同步平台,分割
253 */
254 private String platformInfo;
255
256 /**
257 * 创建时间
258 */
259 private LocalDateTime createTime;
260
261 /**
262 * 更新时间
263 */
264 private LocalDateTime updateTime;
265
266 /**
267 * 扩展字段
268 */
269 private List<Long> ContentIdList;
270
271 /**
272 * 标识单集剧集
273 */
274 private Integer SeriesFlag;
275
276 }
1 package com.hui.iqiyi.request;
2
3 import java.time.LocalDateTime;
4
5 import com.hui.iqiyi.config.AppPagingRequest;
6 import lombok.Data;
7
8 /**
9 * <p>
10 * VIEW
11 * </p>
12 *
13 * @author jobob
14 * @since 2021-06-03
15 */
16
17
18 @Data
19 public class MediaRequest extends AppPagingRequest {
20
21 private Long id;
22
23 private String contentId;
24
25 private Long type;
26
27 private String name;
28
29 private String year;
30
31 private String publishTime;
32
33 private Integer status;
34
35 private String tags;
36
37 private Integer excl;
38
39 private String focus;
40
41 private String picUrl;
42
43 private Integer imgPod;
44
45 private Long cid;
46
47 private String cname;
48
49 private String composers;
50
51 private String hosters;
52
53 private String dubbers;
54
55 private String makers;
56
57 private String stars;
58
59 private String producers;
60
61 private String songWriters;
62
63 private String guesters;
64
65 private String writers;
66
67 private String directors;
68
69 private String actors;
70
71 private String sname;
72
73 private Integer isCharge;
74
75 private String vipInfo;
76
77 private Integer isVip;
78
79 private Integer isTvod;
80
81 private Integer isCoupon;
82
83 private Integer isPkg;
84
85 private Integer orgPrc;
86
87 private String validTime;
88
89 private Integer supportProb;
90
91 private String country;
92
93 private String language;
94
95 private String searchName;
96
97 private String score;
98
99 private Integer syncStatus;
100
101 private String desc;
102
103 private Long stype;
104
105 private String persons;
106
107 private Long total;
108
109 private Long currCount;
110
111 private Integer probDuration;
112
113 private LocalDateTime createTime;
114
115 private LocalDateTime updateTime;
116 private Long platformInfo;
117 private String beginTime;
118 private String EndTime;
119
120 //
121 private Integer downloadStatus;
122
123 //是否是关注列表
124 private Integer follow;
125 }
1 package com.hui.iqiyi.request;
2
3 import com.hui.iqiyi.config.AppPagingRequest;
4 import com.hui.iqiyi.entity.Movie;
5 import lombok.Data;
6
7 import java.time.LocalDateTime;
8 import java.util.List;
9
10 @Data
11 public class MovieRequest extends AppPagingRequest {
12
13 private Integer id;
14 /**
15 * 码流id
16 */
17 private String vid;
18
19 /**
20 * 类型
21 */
22 private String elementType;
23
24 /**
25 * program对象的父节点series对象
26 */
27 private String parentId;
28
29 /**
30 * 内部关联关系id,iqiyi_program表id
31 */
32 private Long iqiyiProgramId;
33
34 /**
35 * tar包下载地址
36 */
37 private String url;
38
39 /**
40 * tar包大小(单位: Byte)
41 */
42 private Long fileSize;
43
44 /**
45 * 码流时长
46 */
47 private Integer duration;
48
49 /**
50 * 清晰度：1080P、720P等
51 */
52 private String bitrate;
53
54 /**
55 * 0：失效；1：生效
56 */
57 private Integer status;
58
59 /**
60 * 本地保存的地址
61 */
62 private String localPath;
63
64 /**
65 * 本地保存ftp的地址
66 */
67 private String localFtpPath;
68
69 /**
70 * 本地状态：0 未下载（需要重新下载）;10 下载中;-100 下载失败;100 下载成功;200 成功回调
71 */
72 private Integer localStatus;
73
74 /**
75 * md5计算
76 */
77 private String md5;
78
79 /**
80 * 本地下载的文件大小
81 */
82 private Long localFileSize;
83
84 /**
85 * 下载重试次数
86 */
87 private Integer retryTimes;
88
89 /**
90 * 下载优先级
91 */
92 private Integer priority;
93
94 /**
95 * 下载错误描述
96 */
97 private String errorDescription;
98
99 /**
100 * 创建时间
101 */
102 private LocalDateTime createTime;
103
104 /**
105 * 更新时间
106 */
107 private LocalDateTime updateTime;
108
109 /**
110 * 扩展字段，关联主表ID
111 * 用于关注更新等操作
112 */
113 private Long contentId;
114
115 /**
116 * 扩展字段，关联主表ID
117 * 用于关注更新等操作list
118 */
119 private List<Long> contentIdList;
120 }
1 package com.hui.iqiyi.request;
2
3 import lombok.Data;
4
5
6 @Data
7 public class ProRequest {
8
9 private String startTime;
10 private String endTime;
11 }
1 package com.hui.iqiyi.request;
2
3 import com.hui.iqiyi.config.AppPagingRequest;
4 import lombok.Data;
5
6 import java.time.LocalDateTime;
7 import java.util.ArrayList;
8 import java.util.List;
9
10 @Data
11 public class ProgramRequest extends AppPagingRequest {
12 private static final long serialVersionUID = 1L;
13
14 private Long id;
15
16 /**
17 * 外部id,爱奇艺的id
18 */
19 private Long externalId;
20
21 /**
22 * 全局内容标识
23 */
24 private String contentId;
25
26 /**
27 * 类型
28 */
29 private String elementType;
30
31 /**
32 * program对象的父节点series对象
33 */
34 private String parentId;
35
36 /**
37 * 内部关联关系id,iqiyi_content表id
38 */
39 private Long iqiyiContentId;
40
41 /**
42 * 区分单视频和剧集
43 */
44 private Integer seriesFlag;
45
46 /**
47 * 节目名称
48 */
49 private String name;
50
51 /**
52 * 国家地区。多个地区以英文逗号分隔
53 */
54 private String country;
55
56 /**
57 * 语言。多个语言以英文逗号分隔
58 */
59 private String language;
60
61 /**
62 * 上映年份（YYYY）
63 */
64 private String year;
65
66 /**
67 * 首播日期（YYYYMMDD）
68 */
69 private String publishTime;
70
71 /**
72 * 节目描述
73 */
74 private String desc;
75
76 /**
77 * 0：失效；1：生效
78 */
79 private Integer status;
80
81 /**
82 * 关联标签
83 */
84 private String tags;
85
86 /**
87 * 一句话看点
88 */
89 private String focus;
90
91 /**
92 * 播放时长（单位为分钟）
93 */
94 private Integer length;
95
96 /**
97 * 封面图，使用时需要拼接尺寸，结合imgPod字段能使用
98 */
99 private String picUrl;
100
101 /**
102 * 封面图片是否支持按需生产 0：不支持；1：支持
103 */
104 private Integer imgPod;
105
106 /**
107 * 所属频道ID
108 */
109 private Integer cid;
110
111 /**
112 * 频道名称
113 */
114 private String cname;
115
116 /**
117 * 是否独播 1：是；其他：否
118 */
119 private Integer excl;
120
121 /**
122 * 是否3D：1：是，0：否
123 */
124 private Integer type3d;
125
126 /**
127 * 视频内容类型，枚举参考附录3.2、内容类型
128 */
129 private Integer contentType;
130
131 /**
132 * 人物信息（JSON）
133 */
134 private String persons;
135
136 /**
137 * 作曲
138 */
139 private String composers;
140
141 /**
142 * 主持人
143 */
144 private String hosters;
145
146 /**
147 * 配音
148 */
149 private String dubbers;
150
151 /**
152 * 制片人
153 */
154 private String makers;
155
156 /**
157 * 明星
158 */
159 private String stars;
160
161 /**
162 * 出品人
163 */
164 private String producers;
165
166 /**
167 * 作词
168 */
169 private String songWriters;
170
171 /**
172 * 嘉宾
173 */
174 private String guesters;
175
176 /**
177 * 编剧
178 */
179 private String writers;
180
181 /**
182 * 导演
183 */
184 private String directors;
185
186 /**
187 * 主演（JSONArray）character：角色名称；name：演员名称；id：演员id
188 */
189 private String mainActors;
190
191 /**
192 * 演员（JSONArray）character：角色名称；name：演员名称；id：演员id
193 */
194 private String actors;
195
196 /**
197 * 短标题
198 */
199 private String sname;
200
201 /**
202 * 是否收费
203 */
204 private Integer isCharge;
205
206 /**
207 * VIP信息节点（JSON）
208 */
209 private String vipInfo;
210
211 /**
212 * 是否会员节目 0：非会员；1：会员
213 */
214 private Integer isVip;
215
216 /**
217 * 是否点播节目 0：非点播；1：点播
218 */
219 private Integer isTvod;
220
221 /**
222 * 是否点播券节目 0：非点播券；1：点播券
223 */
224 private Integer isCoupon;
225
226 /**
227 * 是否点播套餐节目 0：非点播套餐；1：点播套餐
228 */
229 private Integer isPkg;
230
231 /**
232 * 点播节目原价，仅在is_tvod为1时才有这个字段，单位为分
233 */
234 private Integer orgPrc;
235
236 /**
237 * 有效期，仅在is_tvod为1时才有这个字段，24h、30d
238 */
239 private String validTime;
240
241 /**
242 * 是否支持试看 1：支持；0：不支持
243 */
244 private Integer supportProb;
245
246 /**
247 * 试看时长，单位毫秒
248 */
249 private Integer probDuration;
250
251 /**
252 * 索引名称
253 */
254 private String searchName;
255
256 /**
257 * 排序辅助字段
258 */
259 private Integer multiOrder;
260
261 /**
262 * 当前集数
263 */
264 private Integer volumnCount;
265
266 /**
267 * 用户评分
268 */
269 private String score;
270
271 /**
272 * 同步标识 0：未进行同步，1：同步成功，-1： 同步失败
273 */
274 private Integer syncStatus;
275
276 /**
277 * 同步平台,分割
278 */
279 private String platformInfo;
280
281 /**
282 * 码流信息同步标识：0：未进行同步，1：同步成功，-1： 同步失败
283 */
284 private Integer fileStatus;
285
286 /**
287 * 创建时间
288 */
289 private LocalDateTime createTime;
290
291 /**
292 * 更新时间
293 */
294 private LocalDateTime updateTime;
295
296 /**
297 * 扩展字段
298 */
299 private List<Long> ContentIdList;
300
301 /**
302 * 扩展字段
303 */
304 private Long downloadCount;
305
306 /**
307 * 下载状态
308 */
309 private String localStatus;
310 }
1 package com.hui.iqiyi.response;
2
3 import lombok.Data;
4
5 @Data
6 public class ContentResponse {
7
8 private Long contentType;
9
10 private String cname;
11 private Long num;
12
13 //剧集
14 private Integer Drama;
15 //单片
16 private Integer monolithic;
17
18
19 }
1 package com.hui.iqiyi.response;
2
3 import lombok.Data;
4
5 import java.util.Date;
6
7 @Data
8 public class MovieResponse {
9 /**
10 * 清晰度：1080P、720P等
11 */
12 private String bitrate;
13 /**
14 * 本地保存的地址
15 */
16 private String localPath;
17 /**
18 * maliushichang-
19 */
20 private Integer Duration;
21
22
23 private Date day1;
24 private Double TotlSize2;
25 private Long TotlFee3;
26 private Double TotlDuration4;
27
28 }
1 package com.hui.iqiyi.response;
2
3 import lombok.Data;
4
5 @Data
6 public class ProgramQBRequest {
7
8
9 //状态
10 private Long localStatus;
11 //数量
12 private Long totalFee;
13 //容量
14 private Double totleSize;
15 //时长
16 private Double totalduration;
17 }
1 package com.hui.iqiyi.response;
2
3 import com.baomidou.mybatisplus.annotation.TableName;
4 import lombok.Data;
5 import lombok.EqualsAndHashCode;
6 import lombok.experimental.Accessors;
7
8 import java.io.Serializable;
9 import java.time.LocalDateTime;
10 import java.util.List;
11
12 /**
13 * <p>
14 *
15 * </p>
16 *
17 * @author jobob
18 * @since 2021-06-03
19 */
20 @Data
21 public class ProgramResponse {
22
23 private Long id;
24
25 /**
26 * 外部id,爱奇艺的id
27 */
28 private Long externalId;
29
30 /**
31 * 全局内容标识
32 */
33 private String contentId;
34
35 /**
36 * 类型
37 */
38 private String elementType;
39
40 /**
41 * program对象的父节点series对象
42 */
43 private String parentId;
44
45 /**
46 * 内部关联关系id,iqiyi_content表id
47 */
48 private Long iqiyiContentId;
49
50 /**
51 * 区分单视频和剧集
52 */
53 private Integer seriesFlag;
54
55 /**
56 * 节目名称
57 */
58 private String name;
59
60 /**
61 * 国家地区。多个地区以英文逗号分隔
62 */
63 private String country;
64
65 /**
66 * 语言。多个语言以英文逗号分隔
67 */
68 private String language;
69
70 /**
71 * 上映年份（YYYY）
72 */
73 private String year;
74
75 /**
76 * 首播日期（YYYYMMDD）
77 */
78 private String publishTime;
79
80 /**
81 * 节目描述
82 */
83 private String desc;
84
85 /**
86 * 0：失效；1：生效
87 */
88 private Integer status;
89
90 /**
91 * 关联标签
92 */
93 private String tags;
94
95 /**
96 * 一句话看点
97 */
98 private String focus;
99
100 /**
101 * 播放时长（单位为分钟）
102 */
103 private Integer length;
104
105 /**
106 * 封面图，使用时需要拼接尺寸，结合imgPod字段能使用
107 */
108 private String picUrl;
109
110 /**
111 * 封面图片是否支持按需生产 0：不支持；1：支持
112 */
113 private Integer imgPod;
114
115 /**
116 * 所属频道ID
117 */
118 private Integer cid;
119
120 /**
121 * 频道名称
122 */
123 private String cname;
124
125 /**
126 * 是否独播 1：是；其他：否
127 */
128 private Integer excl;
129
130 /**
131 * 是否3D：1：是，0：否
132 */
133 private Integer type3d;
134
135 /**
136 * 视频内容类型，枚举参考附录3.2、内容类型
137 */
138 private Integer contentType;
139
140 /**
141 * 人物信息（JSON）
142 */
143 private String persons;
144
145 /**
146 * 作曲
147 */
148 private String composers;
149
150 /**
151 * 主持人
152 */
153 private String hosters;
154
155 /**
156 * 配音
157 */
158 private String dubbers;
159
160 /**
161 * 制片人
162 */
163 private String makers;
164
165 /**
166 * 明星
167 */
168 private String stars;
169
170 /**
171 * 出品人
172 */
173 private String producers;
174
175 /**
176 * 作词
177 */
178 private String songWriters;
179
180 /**
181 * 嘉宾
182 */
183 private String guesters;
184
185 /**
186 * 编剧
187 */
188 private String writers;
189
190 /**
191 * 导演
192 */
193 private String directors;
194
195 /**
196 * 主演（JSONArray）character：角色名称；name：演员名称；id：演员id
197 */
198 private String mainActors;
199
200 /**
201 * 演员（JSONArray）character：角色名称；name：演员名称；id：演员id
202 */
203 private String actors;
204
205 /**
206 * 短标题
207 */
208 private String sname;
209
210 /**
211 * 是否收费
212 */
213 private Integer isCharge;
214
215 /**
216 * VIP信息节点（JSON）
217 */
218 private String vipInfo;
219
220 /**
221 * 是否会员节目 0：非会员；1：会员
222 */
223 private Integer isVip;
224
225 /**
226 * 是否点播节目 0：非点播；1：点播
227 */
228 private Integer isTvod;
229
230 /**
231 * 是否点播券节目 0：非点播券；1：点播券
232 */
233 private Integer isCoupon;
234
235 /**
236 * 是否点播套餐节目 0：非点播套餐；1：点播套餐
237 */
238 private Integer isPkg;
239
240 /**
241 * 点播节目原价，仅在is_tvod为1时才有这个字段，单位为分
242 */
243 private Integer orgPrc;
244
245 /**
246 * 有效期，仅在is_tvod为1时才有这个字段，24h、30d
247 */
248 private String validTime;
249
250 /**
251 * 是否支持试看 1：支持；0：不支持
252 */
253 private Integer supportProb;
254
255 /**
256 * 试看时长，单位毫秒
257 */
258 private Integer probDuration;
259
260 /**
261 * 索引名称
262 */
263 private String searchName;
264
265 /**
266 * 排序辅助字段
267 */
268 private Integer multiOrder;
269
270 /**
271 * 当前集数
272 */
273 private Integer volumnCount;
274
275 /**
276 * 用户评分
277 */
278 private String score;
279
280 /**
281 * 同步标识 0：未进行同步，1：同步成功，-1： 同步失败
282 */
283 private Integer syncStatus;
284
285 /**
286 * 同步平台,分割
287 */
288 private String platformInfo;
289
290 /**
291 * 码流信息同步标识：0：未进行同步，1：同步成功，-1： 同步失败
292 */
293 private Integer fileStatus;
294
295 /**
296 * 创建时间
297 */
298 private LocalDateTime createTime;
299
300 /**
301 * 更新时间
302 */
303 private LocalDateTime updateTime;
304
305 /**
306 * 扩展字段
307 */
308 private List<Long> ContentIdList;
309
310 /**
311 * 扩展字段
312 */
313 private Long downloadCount;
314
315 /**
316 * 下载状态
317 */
318 private String localStatus;
319
320
321 //剧集资源
322 List<MovieResponse> movieResponseList;
323 }
1 package com.hui.iqiyi.response;
2
3 import lombok.Data;
4
5
6 @Data
7 public class ProgramSyResponse {
8
9 private String day;
10 //剧集
11 private Integer Drama;
12 //单片
13 private Integer monolithic;
14 //下载数量
15 private Long xzNumbe;
16 //下载容量
17 private Double xzSize;
18 //下载时长
19 private Double totlDuration;
20
21 //下载失败的数量
22 private Long failSum;
23 //同步未下载数量
24 private Long totlSize;
25 //未同步介质数量
26 private Long totlFee;
27
28
29 }
1 package com.hui.iqiyi.service;
2
3 import com.hui.iqiyi.Util.ReturnBean;
4 import com.hui.iqiyi.entity.Content;
5 import com.baomidou.mybatisplus.extension.service.IService;
6 import com.hui.iqiyi.request.ContentRequest;
7 import com.hui.iqiyi.response.ContentResponse;
8
9 import java.util.List;
10
11 /**
12 * <p>
13 * 服务类
14 * </p>
15 *
16 * @author jobob
17 * @since 2021-06-03
18 */
19 public interface IContentService extends IService<Content> {
20 /**
21 * 修改剧头表的公共方法
22 *
23 * @param content
24 * @return
25 */
26 ReturnBean updateContent(Content content);
27
28
29 /**
30 * 查询单集
31 *
32 * @param request
33 * @param id
34 * @return
35 */
36 List<Content> selectAllSingle(ContentRequest request, Long id);
37
38
39 /**
40 * 各类型统计数量
41 *
42 * @param contentResponse
43 * @return
44 */
45 List<ContentResponse> selectAllType(ContentResponse contentResponse);
46
47
48 /**
49 * 吉林单片
50 *
51 * @param
52 * @return
53 */
54 ContentResponse selectAllCont();
55
56
57 }
1 package com.hui.iqiyi.service;
2
3 import com.baomidou.mybatisplus.core.metadata.IPage;
4 import com.hui.iqiyi.entity.Media;
5 import com.baomidou.mybatisplus.extension.service.IService;
6 import com.hui.iqiyi.request.MediaRequest;
7
8 import java.util.List;
9
10 /**
11 * <p>
12 * VIEW 服务类
13 * </p>
14 *
15 * @author jobob
16 * @since 2021-06-03
17 */
18 public interface IMediaService extends IService<Media> {
19 /**
20 * 查询所有剧集
21 *
22 * @param iqiyiContent
23 * @return
24 */
25
26 IPage<Media> selectAllIqIy(MediaRequest iqiyiContent);
27
28 /**
29 * 查询所有剧集
30 *
31 * @param iqiyiContent
32 * @return
33 */
34
35 List<Media> selectAllIqIyList(MediaRequest iqiyiContent);
36
37 /**
38 * 查询平台所关注的信息
39 *
40 * @param info
41 * @return
42 */
43
44 List<Media> selectAllfollow(MediaRequest info);
45 }
1 package com.hui.iqiyi.service;
2
3 import com.baomidou.mybatisplus.core.metadata.IPage;
4 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
5 import com.hui.iqiyi.Util.ReturnBean;
6 import com.hui.iqiyi.entity.Movie;
7 import com.baomidou.mybatisplus.extension.service.IService;
8 import com.hui.iqiyi.request.MovieRequest;
9 import com.hui.iqiyi.request.ProRequest;
10 import com.hui.iqiyi.response.MovieResponse;
11
12 import java.util.List;
13 import java.util.Map;
14
15 /**
16 * <p>
17 * 服务类
18 * </p>
19 *
20 * @author jobob
21 * @since 2021-06-03
22 */
23 public interface IMovieService extends IService<Movie> {
24 /**
25 * 修改优先级分开写，因为需要关联更新
26 *
27 * @return
28 */
29 ReturnBean updateMoviePriority(Movie movie);
30
31 //查询总体下载情况
32
33 List<Movie> selectAllPopulation(Movie movie);
34
35
36 /**
37 * 近七日同步
38 *
39 * @return
40 */
41 List<MovieResponse> selectAllSevenxz(ProRequest proRequest);
42 }
1 package com.hui.iqiyi.service;
2
3 import com.hui.iqiyi.Util.ReturnBean;
4 import com.hui.iqiyi.entity.Movie;
5 import com.hui.iqiyi.entity.Program;
6 import com.baomidou.mybatisplus.extension.service.IService;
7 import com.hui.iqiyi.request.ByIdsRequest;
8 import com.hui.iqiyi.request.ProRequest;
9 import com.hui.iqiyi.request.ProgramRequest;
10 import com.hui.iqiyi.response.MovieResponse;
11 import com.hui.iqiyi.response.ProgramResponse;
12 import com.hui.iqiyi.response.ProgramSyResponse;
13 import org.springframework.context.annotation.Primary;
14
15 import java.util.List;
16 import java.util.Map;
17
18 /**
19 * <p>
20 * 服务类
21 * </p>
22 *
23 * @author jobob
24 * @since 2021-06-03
25 */
26 public interface IProgramService extends IService<Program> {
27
28 //最新添加关注
29 ReturnBean updateByProgramIds(List<ByIdsRequest> requests);
30
31 /**
32 * 获取每一集的下载状态
33 *
34 * @return
35 */
36 List<ProgramRequest> selectDownload(ProgramRequest program);
37
38 /**
39 * 查询关注平台信息
40 *
41 * @param program
42 * @return
43 */
44 Map<Program, List<Movie>> selectProMov(Program program, int PageNo, int PageSize);
45
46 /**
47 * 返回Program信息
48 */
49 List<ProgramRequest> selectProgramList(ProgramRequest program);
50
51 /**
52 * 返回Program信息,连带着下载状态
53 */
54 List<ProgramResponse> selectProgramDloadList(ProgramRequest program);
55
56
57 /**
58 * 近七日下载
59 *
60 * @return
61 */
62 List<ProgramSyResponse> selectAllSeven(ProRequest proRequest);
63
64
65 /**
66 * 关注平台数据
67 *
68 * @param
69 * @return
70 */
71 ProgramSyResponse selectAllProgramCount();
72
73
74 }
1 package com.hui.iqiyi.service.impl;
2
3 import com.hui.iqiyi.Util.ReturnBean;
4 import com.hui.iqiyi.entity.Content;
5 import com.hui.iqiyi.entity.Movie;
6 import com.hui.iqiyi.entity.Program;
7 import com.hui.iqiyi.mapper.ContentMapper;
8 import com.hui.iqiyi.request.ContentRequest;
9 import com.hui.iqiyi.response.ContentResponse;
10 import com.hui.iqiyi.service.IContentService;
11 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
12 import com.hui.iqiyi.service.IMovieService;
13 import com.hui.iqiyi.service.IProgramService;
14 import org.apache.commons.lang3.ObjectUtils;
15 import org.springframework.beans.factory.annotation.Autowired;
16 import org.springframework.context.annotation.Primary;
17 import org.springframework.stereotype.Service;
18 import org.springframework.transaction.annotation.Transactional;
19
20 import javax.annotation.Resource;
21 import java.util.List;
22
23 /**
24 * <p>
25 * 服务实现类
26 * </p>
27 *
28 * @author jobob
29 * @since 2021-06-03
30 */
31 @Service
32 @Primary
33 public class ContentServiceImpl extends ServiceImpl<ContentMapper, Content> implements IContentService {
34
35 @Resource
36 private ContentMapper contentMapper;
37
38 @Autowired
39 private IContentService iContentService;
40
41 @Autowired
42 private IProgramService iProgramService;
43
44 @Autowired
45 private IMovieService iMovieService;
46
47 @Override
48 public ReturnBean updateContent(Content content) {
49 System.out.println("---------------------更新" + content.toString());
50 if (ObjectUtils.isEmpty(content))
51 throw new RuntimeException("传入的信息不能为空！");
52
53
54 try {
55 if (contentMapper.updateContent(content) == 0)
56 ReturnBean.errorSuccessInfo("更新失败！");
57 } catch (Exception e) {
58 throw new RuntimeException("更新表头出现错误！错误信息如下" + e.getMessage());
59 }
60 return ReturnBean.setSuccessInfo("更新成功！");
61 }
62
63 //查询单集列表
64 @Override
65 public List<Content> selectAllSingle(ContentRequest request, Long id) {
66 return contentMapper.selectAllSingle(request, id);
67 }
68
69
70 @Override
71 public List<ContentResponse> selectAllType(ContentResponse contentResponse) {
72 return contentMapper.selectAllType(contentResponse);
73 }
74
75 @Override
76 public ContentResponse selectAllCont() {
77 List<Integer> integers = contentMapper.selectAllCont();
78 ContentResponse response = new ContentResponse();
79 response.setDrama(integers.get(1));
80 response.setMonolithic(integers.get(0));
81 return response;
82 }
83
84
85 }
1 package com.hui.iqiyi.service.impl;
2
3 import com.baomidou.mybatisplus.core.metadata.IPage;
4 import com.hui.iqiyi.config.AppPagingRequest;
5 import com.hui.iqiyi.entity.Media;
6 import com.hui.iqiyi.entity.Program;
7 import com.hui.iqiyi.mapper.MediaMapper;
8 import com.hui.iqiyi.request.MediaRequest;
9 import com.hui.iqiyi.request.ProgramRequest;
10 import com.hui.iqiyi.service.IMediaService;
11 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
12 import com.hui.iqiyi.service.IProgramService;
13 import org.apache.commons.lang3.ObjectUtils;
14 import org.springframework.beans.factory.annotation.Autowired;
15 import org.springframework.context.annotation.Primary;
16 import org.springframework.stereotype.Service;
17
18 import java.util.List;
19 import java.util.stream.Collectors;
20
21 /**
22 * <p>
23 * VIEW 服务实现类
24 * </p>
25 *
26 * @author jobob
27 * @since 2021-06-03
28 */
29 /*
30 继续改 参数 返回值
31 */
32 @Service
33 @Primary
34 public class MediaServiceImpl extends ServiceImpl<MediaMapper, Media> implements IMediaService {
35
36 @Autowired
37 private MediaMapper mediaMapper;
38
39 @Autowired
40 private IProgramService programService;
41
42 @Override
43 public IPage<Media> selectAllIqIy(MediaRequest iqiyiContent) {
44 try {
45 // return mediaMapper.selectAllIqIy(AppPagingRequest.getPage(iqiyiContent),iqiyiContent);
46
47 } catch (Exception e) {
48 throw new RuntimeException("服务器错误，错误原因是：" + e.getMessage() + "请联系运维！");
49 }
50 return null;
51 }
52
53 @Override
54 public List<Media> selectAllIqIyList(MediaRequest iqiyiContent) {
55 List<Media> list = null;
56 try {
57 list = mediaMapper.selectAllIqIy(iqiyiContent);
58 if (list.size() == 0)
59 return list;
60 ProgramRequest programRequest = new ProgramRequest();
61 programRequest.setContentIdList(list.stream().map(Long -> Long.getId()).collect(Collectors.toList()));
62 List<ProgramRequest> listPro = programService.selectDownload(programRequest);
63 for (Media media : list) {
64 for (ProgramRequest pro : listPro) {
65 if (media.getId().compareTo(pro.getIqiyiContentId()) == 0) {
66 //如果剧头的总集数与下载量一直则显示全部下载完成
67 if (media.getCurrCount().compareTo(pro.getDownloadCount()) == 0) {
68 media.setDownloadStatus("全部下载完成");
69 continue;
70 }
71 //如果剧头的总集数 大于 下载量 就显示未全部下载
72 if (media.getCurrCount().compareTo(pro.getDownloadCount()) > 0) {
73 media.setDownloadStatus("未全部下载");
74 continue;
75 }
76 }
77 }
78 //里面是关联查询匹配，如果没有下载记录，就塞入未下载
79 if (ObjectUtils.isEmpty(media.getDownloadStatus()))
80 media.setDownloadStatus("未下载");
81 }
82 } catch (Exception e) {
83 throw new RuntimeException("服务器错误，错误原因是：" + e.getMessage() + "请联系运维！");
84 }
85 return list;
86 }
87
88
89 @Override
90 public List<Media> selectAllfollow(MediaRequest info) {
91 return mediaMapper.selectAllfollow(info);
92 }
93 }
1 package com.hui.iqiyi.service.impl;
2
3 import com.hui.iqiyi.Util.ReturnBean;
4 import com.hui.iqiyi.entity.Movie;
5 import com.hui.iqiyi.mapper.MovieMapper;
6 import com.hui.iqiyi.request.MovieRequest;
7 import com.hui.iqiyi.request.ProRequest;
8 import com.hui.iqiyi.response.MovieResponse;
9 import com.hui.iqiyi.service.IMovieService;
10 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
11 import org.apache.commons.lang3.ObjectUtils;
12 import org.springframework.beans.factory.annotation.Autowired;
13 import org.springframework.context.annotation.Primary;
14 import org.springframework.stereotype.Service;
15 import org.springframework.transaction.annotation.Transactional;
16
17 import java.util.List;
18
19 /**
20 * <p>
21 * 服务实现类
22 * </p>
23 *
24 * @author jobob
25 * @since 2021-06-03
26 */
27 @Service
28 @Primary
29 public class MovieServiceImpl extends ServiceImpl<MovieMapper, Movie> implements IMovieService {
30
31 @Autowired
32 private MovieMapper movieMapper;
33
34 @Override
35 public ReturnBean updateMoviePriority(Movie movie) throws RuntimeException {
36 if (ObjectUtils.isEmpty(movie))
37 throw new RuntimeException("传入的信息不能为空！");
38
39 ReturnBean returnBean = null;
40 try {
41 if (movieMapper.updateMoviePriority(movie) > 0)
42 ReturnBean.errorSuccessInfo("更新失败！");
43 } catch (Exception e) {
44 throw new RuntimeException("更新电影出现错误！错误信息如下" + e.getMessage());
45 }
46 return ReturnBean.setSuccessInfo("更新成功！");
47 }
48
49
50 @Override
51 public List<Movie> selectAllPopulation(Movie movie) {
52 return movieMapper.selectAllPopulation(movie);
53 }
54
55 @Override
56 public List<MovieResponse> selectAllSevenxz(ProRequest proRequest) {
57 return movieMapper.selectAllSevenxz(proRequest);
58 }
59 }
1 package com.hui.iqiyi.service.impl;
2
3 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
4 import com.github.pagehelper.PageHelper;
5 import com.github.pagehelper.PageInfo;
6 import com.hui.iqiyi.Util.ReturnBean;
7 import com.hui.iqiyi.Util.ReturnProgram;
8 import com.hui.iqiyi.entity.Movie;
9 import com.hui.iqiyi.entity.Program;
10 import com.hui.iqiyi.mapper.ContentMapper;
11 import com.hui.iqiyi.mapper.MovieMapper;
12 import com.hui.iqiyi.mapper.ProgramMapper;
13 import com.hui.iqiyi.request.ByIdsRequest;
14 import com.hui.iqiyi.request.ProRequest;
15 import com.hui.iqiyi.request.ProgramRequest;
16 import com.hui.iqiyi.response.*;
17 import com.hui.iqiyi.service.IProgramService;
18 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
19 import org.apache.commons.lang3.ObjectUtils;
20 import org.springframework.beans.BeanUtils;
21 import org.springframework.beans.factory.annotation.Autowired;
22 import org.springframework.context.annotation.Primary;
23 import org.springframework.stereotype.Service;
24 import org.springframework.transaction.annotation.Transactional;
25
26 import javax.annotation.Resource;
27 import java.math.BigDecimal;
28 import java.util.ArrayList;
29 import java.util.HashMap;
30 import java.util.List;
31 import java.util.Map;
32 import java.util.stream.Collectors;
33
34 /**
35 * <p>
36 * 服务实现类
37 * </p>
38 *
39 * @author jobob
40 * @since 2021-06-03
41 */
42 @Service
43 @Primary
44 public class ProgramServiceImpl extends ServiceImpl<ProgramMapper, Program> implements IProgramService {
45
46 @Resource
47 private ProgramMapper programMapper;
48
49 @Autowired
50 private MovieMapper movieMapper;
51
52 @Resource
53 private ContentMapper contentMapper;
54
55 @Override
56 @Transactional
57 public ReturnBean updateByProgramIds(List<ByIdsRequest> requests) {
58 ReturnBean returnBean = null;
59 try {
60 if (ObjectUtils.isEmpty(requests))
61 returnBean.errorSuccessInfo("传入的ID不能为空");
62 // requests.stream().filter(item->item.getType().equals(0)).
63 for (ByIdsRequest id : requests) {
64 if (id.getType() == 0) {//电影
65 int i1 = programMapper.updateFilm(id.getId());
66 if (i1 == 0) {
67 throw new RuntimeException("添加关注失败!");
68 }
69 } else if (id.getType() == 1) {//剧集
70 //MyBatisPlus 的通过id查询
71 int i1 = programMapper.updatePla(id.getId());
72 int pla = programMapper.updateTeleplay(id.getId());
73 if (i1 == 0 && pla == 0) {
74 throw new RuntimeException("添加关注失败!");
75 }
76 }
77 }
78 } catch (Exception e) {
79 returnBean.errorSuccessInfo("添加关注异常，原因是" + e.getMessage());
80 }
81 return returnBean.setSuccessInfo("添加关注成功!");
82 }
83
84 /**
85 * 获取每一集的下载状态
86 *
87 * @return
88 */
89 @Override
90 public List<ProgramRequest> selectDownload(ProgramRequest program) {
91 return programMapper.selectDownload(program);
92 }
93
94 /**
95 * 查询关注平台信息
96 *
97 * @param program
98 * @return
99 */
100 @Override
101 public Map<Program, List<Movie>> selectProMov(Program program, int PageNo, int PageSize) {
102 Map<Program, List<Movie>> programMovieMap = new HashMap<>();
103 //查询集表信息
104 QueryWrapper<Program> wrapper = new QueryWrapper<>();
105 System.out.println("====================" + program.getPlatformInfo());
106 wrapper.eq("platform_info", program.getPlatformInfo());
107
108 //分页查询
109 PageHelper.startPage(PageNo, PageSize);
110 PageInfo<Program> pageInfo = new PageInfo(programMapper.selectList(wrapper));
111
112 //查询Movie表信息
113 QueryWrapper<Movie> wrapper1 = new QueryWrapper<>();
114 wrapper1.in("iqiyi_program_id", pageInfo.getList().stream().map(item -> item.getId()).collect(Collectors.toList()));
115 List<Movie> listMovie = movieMapper.selectList(wrapper1);
116
117 //循环集表跟Movie表信息进行循环比对，封装成Map进行返回
118 //循环集表
119 List<Movie> Mo = new ArrayList<>();
120 pageInfo.getList().stream().forEach(item -> {
121 Mo.clear();
122 //循环Movie表 使用并行流
123 listMovie.stream().parallel().forEach(movie -> {
124 //如果集表ID与Movie表 IqiyiProgramId 相同，则进行封装成
125 if (item.getId().compareTo(movie.getIqiyiProgramId()) == 0) {
126 Mo.add(movie);
127 }
128 });
129 programMovieMap.put(item, Mo);
130 });
131 pageInfo.getList().clear();
132
133 //获取分页数据传递给前台
134 ReturnProgram<Program> returnProgram = new ReturnProgram<>();
135 returnProgram.setPageNum(pageInfo.getPageNum());
136 returnProgram.setPageSize(pageInfo.getPageSize());
137 returnProgram.setSize(pageInfo.getSize());
138 returnProgram.setStartRow(pageInfo.getStartRow());
139 returnProgram.setEndRow(pageInfo.getEndRow());
140 returnProgram.setPages(pageInfo.getPages());
141 returnProgram.setPrePage(pageInfo.getPrePage());
142 returnProgram.setNextPage(pageInfo.getNextPage());
143
144 returnProgram.setProgramMovieMap(programMovieMap);
145 return programMovieMap;
146 }
147
148 //公共的
149 @Override
150 public List<ProgramRequest> selectProgramList(ProgramRequest program) {
151 return programMapper.selectProgramList(program);
152 }
153
154 //查看单集及其状态
155 @Override
156 public List<ProgramResponse> selectProgramDloadList(ProgramRequest program) {
157 //分页查询剧集内的单集详情信息
158 List<ProgramResponse> programRequests = programMapper.selectProgramDloadList(program);
159 //由于每个单集需要查询出所有的片源信息 两条或三条 所以需要在每个单集详情中 加上一个存储片源信息的List 正好对应两条或三条清晰度的情况
160 //返回内容新建了一个response（请求类）因为继续用实体类不能满足多条清晰度的情况下 数据的完整性 于是就在请求类里面加了个list 这个list类型也是一个类（MovieResponse）
161 //MovieResponse这个类里面封装了两个字段
162 //循环分页后的数据，把多条清晰度加进返回类的list集合里吗
163 for (ProgramResponse response : programRequests) {
164 //Mybatisplus的方法 通过Program表的id 向Movie的iqiyi_program_id查是否相等 相等就代表 这个数据是这个剧集的莫一条清晰度
165 //返回值是list类型的！！！！正好代表多条清晰度的概念 也正好能放在返回类的List<>movieResponseList中
166 //不过由于类型不一样需要进行一些别的操作
167 List<Movie> movies = movieMapper.selectList(new QueryWrapper<Movie>().eq("iqiyi_program_id", response.getId()));
168 //new一个这个是因为需要先存一下子
169 List<MovieResponse> movieResponses = new ArrayList<>();
170 //循环 通过单集查出的不同清晰度数据 为了能塞进返回类的List<>movieResponseList
171 for (Movie m : movies) {
172 //因为数据类型不一样 才new的
173 MovieResponse movieResponse = new MovieResponse();
174 //!!!!这个方法BeanUtils.copyProperties(源对象, 目标对象);
175 //把两个类中相同的字段赋值 下面代表 把m 中的值给movieResponse里
176 //也就是把m与movieResponse相同的字段 拷贝一份过去
177 BeanUtils.copyProperties(m, movieResponse);
178 //于是所需要的两个字段也就有值了
179 //这个是一个list list由add赋值 add(类型一样的一个值)下标就变成0，再写一个add(类型一样的一个值)就变成下标1
180 //理解为!!一个!!剧集的单集下面 所有不同清晰度的片源
181 movieResponses.add(movieResponse);
182 }
183 //set方法 赋值 set(值) 取值 Object i = get（）
184 //set方法标识把这个单集的不同清晰度的片源都放进返回类的 movieResponseList字段里面
185 response.setMovieResponseList(movieResponses);
186 }
187
188 return programRequests;
189 }
190
191 @Override
192 public List<ProgramSyResponse> selectAllSeven(ProRequest proRequest) {
193 return programMapper.selectAllSeven(proRequest);
194 }
195
196 @Override
197 public ProgramSyResponse selectAllProgramCount() {
198 ProgramSyResponse programSyResponse = new ProgramSyResponse();
199 // 剧集单片数量
200 List<Integer> integers = contentMapper.selectAllCont();
201 programSyResponse.setDrama(integers.get(1));
202 programSyResponse.setMonolithic(integers.get(0));
203
204 List<ProgramQBRequest> qbRequest = programMapper.selectAllProgramCount();
205 for (ProgramQBRequest request : qbRequest) {
206 if (request.getLocalStatus() != null) {
207 if (request.getLocalStatus() == 100) {
208 programSyResponse.setXzNumbe(request.getTotalFee());
209 programSyResponse.setXzSize(request.getTotleSize());
210 programSyResponse.setTotlDuration(request.getTotalduration());
211 } else if (request.getLocalStatus() == -10) {
212 programSyResponse.setFailSum(request.getTotalFee());
213 } else if (request.getLocalStatus() == 0) {
214 programSyResponse.setTotlSize(request.getTotalFee());
215 }
216 } else {
217 programSyResponse.setTotlFee(request.getTotalFee());
218 }
219 }
220
221 return programSyResponse;
222
223 }
224
225 }
...\ No newline at end of file ...\ No newline at end of file
1 Manifest-Version: 1.0
2 Main-Class: com.hui.iqiyi.IqiyiApplication
3
1
2 server:
3 port: 9000
4
5 spring:
6 datasource:
7 driver-class-name: com.mysql.cj.jdbc.Driver
8 url: jdbc:mysql://139.196.37.202:3306/hyperion?serverTimezone=Asia/Shanghai&characterEncoding=utf8&useSSL=false&autoReconnect=true
9 username: root
10 password: Topdraw1qaz
11 profiles:
12 active: dev
13
14 mybatis-plus:
15 configuration:
16 log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
17
18 mybatis-plus:
19 mapper-locations: classpath:mapper/iqiyi/*.xml
1 <?xml version="1.0" encoding="UTF-8"?>
2 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
3 <mapper namespace="com.hui.iqiyi.mapper.ContentMapper">
4 <update id="updateContent" parameterType="com.hui.iqiyi.entity.Content">
5 update iqiyi_content
6 <include refid="Set_Cloumn"></include>
7 <include refid="Where_Cloumn"> </include>
8 </update>
9
10
11 <select id="selectAllSingle" resultType="com.hui.iqiyi.entity.Content">
12 select b.*,c.bitrate,c.local_path from iqiyi_content as a
13 LEFT JOIN iqiyi_program as b on a.id =b.iqiyi_content_id
14 LEFT JOIN iqiyi_movie as c on b.id=c.iqiyi_program_id
15 <where>
16 <if test="param1.SeriesFlag !=null and param1.SeriesFlag !='' ">
17 series_flag=1
18 </if>
19 <if test="param2 !=null and param2 !='' ">
20 a.id=#{param2}
21 </if>
22 </where>
23 </select>
24
25
26 <select id="selectAllType" resultType="com.hui.iqiyi.response.ContentResponse" parameterType="com.hui.iqiyi.response.ContentResponse">
27
28 select contentType,cname,count(id) as num from (
29 select cname,'1' as contentType,id from iqiyi_content
30 union select cname, '0' as contentType,id from iqiyi_program where series_flag = 0 ) as m
31 group by contentType,cname order by contentType,cname
32 </select>
33 <select id="selectAllCont" resultType="java.lang.Integer">
34
35 select count(1) from iqiyi_content where platform_info like '%1%'
36 union
37 select count(1) from iqiyi_program where series_flag = 0 and platform_info like '%1%'
38
39 </select>
40
41 <sql id="Where_Cloumn">
42 <where>
43 <if test="id != null and id != ''">
44 id = #{id}
45 </if>
46 <if test="ContentIdList != null">
47 id in
48 <foreach collection="ContentIdList" index="i" item="id" open="(" separator="," close=")">
49 #{id}
50 </foreach>
51 </if>
52 </where>
53 </sql>
54 <sql id="Set_Cloumn">
55 <set>
56 <if test="platformInfo != null" >
57 platform_info = #{platformInfo},
58 </if>
59 </set>
60 </sql>
61 </mapper>
1 <?xml version="1.0" encoding="UTF-8"?>
2 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
3 <mapper namespace="com.hui.iqiyi.mapper.MediaMapper">
4 <select id="selectAllIqIy" resultType="com.hui.iqiyi.entity.Media" parameterType="com.hui.iqiyi.request.MediaRequest">
5
6
7 select im.*
8 from iqiyi_media as im
9 left join iqiyi_program as ip on im.id =ip.iqiyi_content_id
10 LEFT JOIN iqiyi_movie as i on ip.id=i.iqiyi_program_id
11 where 1=1
12 <if test="id != null and id != ''">
13 and id = #{id}
14 </if>
15 <if test="cid != null and cid != ''">
16 and cid = #{cid}
17 </if>
18 <if test="type != null and type != ''">
19 and type = #{type}
20 </if>
21 <if test="name!= null and name!= ''">
22 AND name = #{name}
23 </if>
24 <if test="cname!= null and cname!= ''">
25 AND cname = #{cname}
26 </if>
27 <if test="beginTime != null">
28 and create_time &gt;= #{beginTime}
29 </if>
30 <if test="EndTime != null">
31 and create_time &lt;= #{EndTime}
32 </if>
33 <if test="score != null">
34 and score = #{score}
35 </if>
36 <if test="platformInfo != null">
37 and platform_info = #{platformInfo}
38 </if>
39
40 <if test="follow != null">
41 and platform_info is not null
42 </if>
43 <if test="downloadStatus !=null" >
44 and local_status=#{downloadStatus}
45 </if>
46 ORDER BY create_time desc
47 </select>
48
49 <select id="selectAllfollow" resultType="com.hui.iqiyi.entity.Media">
50 select * from iqiyi_media as a
51 LEFT JOIN iqiyi_program as c on a.id =c.iqiyi_content_id
52 LEFT JOIN iqiyi_movie as d on d.iqiyi_program_id=c.id
53 <where>
54 1=1
55 <if test="platformInfo!=null">
56 and a.platform_info=#{platformInfo}
57 </if>
58 </where>
59
60 ORDER BY a.update_time
61
62 </select>
63
64 <!-- <select id="selectAllIqIy" resultType="com.hui.iqiyi.entity.Media" parameterType="com.hui.iqiyi.request.MediaRequest">-->
65
66 <!-- select im.*-->
67 <!-- from iqiyi_media as im-->
68 <!-- where 1=1-->
69 <!-- <if test="param2.type != null and param2.type != ''">-->
70 <!-- and type = #{param2.type}-->
71 <!-- </if>-->
72 <!-- <if test="param2.name!= null and param2.name!= ''">-->
73 <!-- AND name = #{param2.name}-->
74 <!-- </if>-->
75 <!-- <if test="param2.cname!= null and param2.cname!= ''">-->
76 <!-- AND cname = #{param2.cname}-->
77 <!-- </if>-->
78 <!-- <if test="param2.beginTime != null">-->
79 <!-- and create_time &gt;= #{param2.beginTime}-->
80 <!-- </if>-->
81 <!-- <if test="param2.EndTime != null">-->
82 <!-- and create_time &lt;= #{param2.EndTime}-->
83 <!-- </if>-->
84 <!-- <if test="param2.score != null">-->
85 <!-- and score = #{param2.score}-->
86 <!-- </if>-->
87 <!-- <if test="param2.platform_info != null">-->
88 <!-- and platform_info = #{param2.platform_info}-->
89 <!-- </if>-->
90 <!-- ORDER BY create_time-->
91 <!-- </select>-->
92 </mapper>
1 <?xml version="1.0" encoding="UTF-8"?>
2 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
3 <mapper namespace="com.hui.iqiyi.mapper.MovieMapper">
4
5 <update id="updateMoviePriority" parameterType="com.hui.iqiyi.request.MovieRequest">
6 update iqiyi_movie as im,(
7 select id
8 from iqiyi_program
9 <where>
10 <if test="contentId != null and contentId != ''">
11 iqiyi_content_id = #{contentId}
12 </if>
13 <if test="contentIdList != null">
14 iqiyi_content_id in
15 <foreach collection="contentIdList" index="i" item="id" open="(" separator="," close=")">
16 #{id}
17 </foreach>
18 </if>
19 </where>
20 ) as ip
21 set priority = #{priority}
22 where im.iqiyi_program_id = ip.id
23 </update>
24
25
26 <select id="selectAllPopulation" resultType="com.hui.iqiyi.entity.Movie" parameterType="com.hui.iqiyi.entity.Movie">
27 select local_status, count(1) as'number',sum(file_size)/1024/1024/1024 as'capacity', sum(duration)/60/60 as'duration'
28 from iqiyi_movie where local_status >= 0
29 GROUP BY local_status;
30 </select>
31
32
33 <select id="selectAllSevenxz" resultType="com.hui.iqiyi.response.MovieResponse" parameterType="com.hui.iqiyi.request.ProRequest">
34 SELECT DATE_FORMAT(p.update_time,"%Y-%m-%d")as day1 ,count(p.id) as TotlFee3 ,
35 sum(m.file_size)/1024/1024/1024 as TotlSize2,sum(m.duration)/60/60 as TotlDuration4
36 FROM iqiyi_program p left join iqiyi_movie m on p.id = m.iqiyi_program_id
37 <where>
38 <if test="proRequest.startTime != null">
39 and UNIX_TIMESTAMP(p.update_time) &gt;= UNIX_TIMESTAMP(#{proRequest.startTime})
40 </if>
41 <if test="proRequest.endTime != null">
42 and UNIX_TIMESTAMP(p.update_time) &lt;= UNIX_TIMESTAMP(#{proRequest.endTime})
43 </if>
44 and date_sub(curdate(), interval 7 day) &lt;date(p.update_time)
45
46 </where>
47 GROUP BY DATE_FORMAT(p.update_time,"%Y-%m-%d")
48 order by DATE_FORMAT(p.update_time,"%Y-%m-%d") desc
49
50
51
52 </select>
53 </mapper>
1 <?xml version="1.0" encoding="UTF-8"?>
2 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
3 <mapper namespace="com.hui.iqiyi.mapper.ProgramMapper">
4
5
6 <update id="updateFilm">
7 UPDATE iqiyi_program as a
8 LEFT JOIN iqiyi_movie as c on c.iqiyi_program_id=a.id
9 set a.platform_info=1,c.priority=10
10 where a.id = #{id}
11 </update>
12
13 <update id="updatePla">
14 UPDATE iqiyi_content AS b
15 set b.platform_info=1
16 where b.id = #{id}
17 </update>
18
19 <update id="updateTeleplay">
20 UPDATE iqiyi_program as a
21 LEFT JOIN iqiyi_movie as c on c.iqiyi_program_id=a.id
22 set a.platform_info=1,c.priority=10
23 where a.iqiyi_content_id = #{id}
24 </update>
25
26 <select id="selectDownload" parameterType="com.hui.iqiyi.request.ProgramRequest" resultType="com.hui.iqiyi.request.ProgramRequest">
27 select ip.iqiyi_content_id,count(ip.id) as downloadCount
28 from iqiyi_movie as io left join iqiyi_program as ip
29 on ip.id = io.iqiyi_program_id
30 where io.local_status = '100' and ip.iqiyi_content_id in
31 <foreach collection="contentIdList" index="i" item="id" open="(" separator="," close=")">
32 #{id}
33 </foreach>
34 GROUP BY ip.iqiyi_content_id
35 </select>
36
37
38 <select id="selectProgramList" parameterType="com.hui.iqiyi.request.ProgramRequest" resultType="com.hui.iqiyi.request.ProgramRequest">
39 select
40 <include refid="Pro_Cloumn"></include>
41 from iqiyi_program
42 <include refid="Where_Cloumn"></include>
43 </select>
44
45 <select id="selectProgramDloadList" parameterType="com.hui.iqiyi.request.ProgramRequest" resultType="com.hui.iqiyi.response.ProgramResponse">
46 select
47 <include refid="Pro_Cloumn"></include>
48 ,( select
49 local_status
50 from iqiyi_movie m where iqiyi_program_id =p.id ORDER BY create_time desc limit 1 ) as 'localStatus'
51 from iqiyi_program p
52 <include refid="Where_Cloumn"></include>
53 </select>
54
55
56 <select id="selectAllSeven" parameterType="com.hui.iqiyi.request.ProRequest" resultType="com.hui.iqiyi.response.ProgramSyResponse">
57
58 SELECT DATE_FORMAT(update_time,"%Y-%m-%d")as day ,count(1) as TotlFee ,
59 sum(file_size)/1024/1024/1024 as TotlSize,sum(duration)/60/60 as TotlDuration
60 FROM iqiyi_movie
61 <where>
62 <if test="proRequest.startTime != null">
63 and UNIX_TIMESTAMP(update_time) &gt;= UNIX_TIMESTAMP(#{proRequest.startTime})
64 </if>
65 <if test="proRequest.endTime != null">
66 and UNIX_TIMESTAMP(update_time) &lt;= UNIX_TIMESTAMP(#{proRequest.endTime})
67 </if>
68 and date_sub(curdate(), interval 7 day) &lt; date(update_time)
69 and local_status = 100
70 </where>
71 GROUP BY DATE_FORMAT(update_time,"%Y-%m-%d")
72 order by DATE_FORMAT(update_time,"%Y-%m-%d") desc
73
74
75 </select>
76
77 <select id="selectAllProgramCount" resultType="com.hui.iqiyi.response.ProgramQBRequest">
78
79 select local_status,count(p.id) as total_fee , sum(m.file_size)/1024/1024/1024 as totle_size,sum(m.duration)/60/60 as total_duration
80 from iqiyi_program p left join iqiyi_movie m on p.id = m.iqiyi_program_id
81 where p.platform_info like '%1%'
82 group by local_status
83
84 </select>
85
86
87 <sql id="Pro_Cloumn">
88 id,external_id,content_id,element_type,parent_id,iqiyi_content_id,
89 series_flag,`name`,country,`language`,`year`,publish_time,`desc`,`status`,tags,focus,`length`,pic_url,
90 img_pod,cid,cname,excl,type3d,content_type,persons,composers,hosters,dubbers,makers,stars,producers,
91 song_writers,guesters,writers,directors,main_actors,actors,sname,is_charge,vip_info,is_vip,is_tvod,
92 is_coupon,is_pkg,org_prc,valid_time,support_prob,prob_duration,search_name,multi_order,volumn_count,
93 score,sync_status,platform_info,file_status,create_time,update_time
94 </sql>
95 <sql id="Where_Cloumn">
96 <where>
97 1=1
98 <if test="iqiyiContentId != null">
99 and iqiyi_content_id = #{iqiyiContentId}
100 </if>
101 <if test="id != null ">
102 and id = #{id}
103 </if>
104 <if test="name != null ">
105 and name like "%"#{name}"%"
106
107 </if>
108 <if test="localStatus != null">
109 and local_status = #{localStatus}
110 </if>
111
112 <if test="contentIdList != null">
113 and ip.iqiyi_content_id in
114 <foreach collection="contentIdList" index="i" item="id" open="(" separator="," close=")">
115 #{id}
116 </foreach>
117 </if>
118 </where>
119 </sql>
120 </mapper>
1 package com.hui.iqiyi;
2
3 import org.junit.jupiter.api.Test;
4 import org.springframework.beans.factory.annotation.Autowired;
5 import org.springframework.boot.test.context.SpringBootTest;
6
7 @SpringBootTest
8 class IqiyiApplicationTests {
9
10
11 @Test
12 void contextLoads() {
13
14
15 }
16
17 }