file_name
stringlengths 6
86
| file_path
stringlengths 45
249
| content
stringlengths 47
6.26M
| file_size
int64 47
6.26M
| language
stringclasses 1
value | extension
stringclasses 1
value | repo_name
stringclasses 767
values | repo_stars
int64 8
14.4k
| repo_forks
int64 0
1.17k
| repo_open_issues
int64 0
788
| repo_created_at
stringclasses 767
values | repo_pushed_at
stringclasses 767
values |
|---|---|---|---|---|---|---|---|---|---|---|---|
Period.java | /FileExtraction/Java_unseen/goaiquant_GOAi/engine/model/src/main/java/cqt/goai/model/enums/Period.java | package cqt.goai.model.enums;
/**
* 周期，K线需要使用
* @author GOAi
*/
public enum Period {
// 1分钟
MIN1 (60),
// 3分钟
MIN3 (60 * 3),
// 5分钟
MIN5 (60 * 5),
// 15分钟
MIN15 (60 * 15),
// 30分钟
MIN30 (60 * 30),
// 1小时
HOUR1 (60 * 60),
// 2小时
HOUR2 (60 * 60 * 2),
// 3小时
HOUR3 (60 * 60 * 3),
// 4小时
HOUR4 (60 * 60 * 4),
// 6小时
HOUR6 (60 * 60 * 6),
// 12小时
HOUR12 (60 * 60 * 12),
// 1天
DAY1 (60 * 60 * 24),
// 3天
DAY3 (60 * 60 * 24 * 3),
// 1周
WEEK1 (60 * 60 * 24 * 7),
// 2周
WEEK2 (60 * 60 * 24 * 14),
// 1月
MONTH1 (60 * 60 * 24 * 30);
private int value;
Period(int value) {
this.value = value;
}
public int getValue() {
return value;
}
/**
* 根据值解析周期
* @param value 秒
* @return 周期
*/
public static Period parse(int value) {
switch (value) {
case 60:
return MIN1;
case 60 * 3:
return MIN3;
case 60 * 5:
return MIN5;
case 60 * 15:
return MIN15;
case 60 * 30:
return MIN30;
case 60 * 60:
return HOUR1;
case 60 * 60 * 2:
return HOUR2;
case 60 * 60 * 3:
return HOUR3;
case 60 * 60 * 4:
return HOUR4;
case 60 * 60 * 6:
return HOUR6;
case 60 * 60 * 12:
return HOUR12;
case 60 * 60 * 24:
return DAY1;
case 60 * 60 * 24 * 3:
return DAY3;
case 60 * 60 * 24 * 7:
return WEEK1;
case 60 * 60 * 24 * 14:
return WEEK2;
case 60 * 60 * 24 * 30:
return MONTH1;
default:
return null;
}
}
}
| 2,077 | Java | .java | goaiquant/GOAi | 63 | 31 | 0 | 2019-02-25T10:14:13Z | 2019-12-10T13:02:33Z |
Type.java | /FileExtraction/Java_unseen/goaiquant_GOAi/engine/model/src/main/java/cqt/goai/model/enums/Type.java | package cqt.goai.model.enums;
/**
* 订单类型
* @author GOAi
*/
public enum Type {
// 限价单
LIMIT,
// 市价单
MARKET,
// FOK
FILL_OR_KILL,
// IOC
IMMEDIATE_OR_CANCEL,
}
| 214 | Java | .java | goaiquant/GOAi | 63 | 31 | 0 | 2019-02-25T10:14:13Z | 2019-12-10T13:02:33Z |
RunInfo.java | /FileExtraction/Java_unseen/goaiquant_GOAi/engine/model/src/main/java/cqt/goai/model/other/RunInfo.java | package cqt.goai.model.other;
import lombok.Data;
/**
* 标记程序运行信息
* run 落盘
* node 读取
* @author GOAi
*/
@Data
public class RunInfo {
/**
* 启动时间
*/
private Long startTime;
/**
* 结束时间
*/
private Long endTime;
/**
* 程序当前状态
*/
private RunState runState;
/**
* 程序pid
*/
private Integer pid;
public RunInfo(Long startTime, RunState runState) {
this.startTime = startTime;
this.runState = runState;
}
public RunInfo setRunState(RunState runState) {
this.runState = runState;
return this;
}
}
| 672 | Java | .java | goaiquant/GOAi | 63 | 31 | 0 | 2019-02-25T10:14:13Z | 2019-12-10T13:02:33Z |
RunState.java | /FileExtraction/Java_unseen/goaiquant_GOAi/engine/model/src/main/java/cqt/goai/model/other/RunState.java | package cqt.goai.model.other;
/**
* 运行状态
* STOPPED -> STARTING -> STARTED -> STOPPING -> STOPPED
* @author GOAi
*/
public enum RunState {
/**
* 程序停止运行
*/
STOPPED,
/**
* 启动中
*/
STARTING,
/**
* 启动完毕
*/
STARTED,
/**
* 停止中
*/
STOPPING,
/**
* 意外停止
*/
ERROR
}
| 398 | Java | .java | goaiquant/GOAi | 63 | 31 | 0 | 2019-02-25T10:14:13Z | 2019-12-10T13:02:33Z |
Trade.java | /FileExtraction/Java_unseen/goaiquant_GOAi/engine/model/src/main/java/cqt/goai/model/market/Trade.java | package cqt.goai.model.market;
import com.alibaba.fastjson.JSONArray;
import cqt.goai.model.To;
import cqt.goai.model.Util;
import cqt.goai.model.enums.Side;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.ToString;
import org.slf4j.Logger;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Objects;
/**
* 成交信息
* @author GOAi
*/
@Getter
@ToString
@EqualsAndHashCode
public class Trade implements To, Serializable {
private static final long serialVersionUID = 514750454318716315L;
/**
* 交易所返回的原始数据, 防止有些用户需要一些特殊的数据
*/
private final String data;
/**
* 时间戳
*/
private final Long time;
/**
* 交易id
*/
private final String id;
/**
* 方向
*/
private final Side side;
/**
* 价格
*/
private final BigDecimal price;
/**
* 数量
*/
private final BigDecimal amount;
public Trade(String data, Long time, String id, Side side, BigDecimal price, BigDecimal amount) {
this.data = data;
this.time = time;
this.id = id;
this.side = side;
this.price = Util.strip(price);
this.amount = Util.strip(amount);
}
@Override
public String to() {
return '[' +
Util.encode(this.data) +
',' + Util.to(this.time) +
',' + Util.to(this.id) +
',' + Util.to(this.side) +
',' + Util.to(this.price) +
',' + Util.to(this.amount) +
']';
}
public double price() {
Objects.requireNonNull(this.price);
return this.price.doubleValue();
}
public double amount() {
Objects.requireNonNull(this.amount);
return this.amount.doubleValue();
}
public static Trade of(String data, Logger log) {
return Util.of(data, Trade::of, log);
}
static Trade of(JSONArray r) {
return new Trade(
Util.decode(r.getString(0)),
r.getLong(1),
r.getString(2),
Util.of(r.getString(3), Side::valueOf),
r.getBigDecimal(4),
r.getBigDecimal(5));
}
}
| 2,292 | Java | .java | goaiquant/GOAi | 63 | 31 | 0 | 2019-02-25T10:14:13Z | 2019-12-10T13:02:33Z |
Depth.java | /FileExtraction/Java_unseen/goaiquant_GOAi/engine/model/src/main/java/cqt/goai/model/market/Depth.java | package cqt.goai.model.market;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import cqt.goai.model.To;
import cqt.goai.model.Util;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.ToString;
import org.slf4j.Logger;
import java.io.Serializable;
/**
* 盘口深度
* @author GOAi
*/
@Getter
@ToString
@EqualsAndHashCode
public class Depth implements To, Serializable {
private static final long serialVersionUID = -8133481259875889084L;
/**
* 时间戳
*/
private final Long time;
/**
* 卖盘数据，由低到高
*/
private final Rows asks;
/**
* 买盘数据，由高到低
*/
private final Rows bids;
public Depth(Long time, Rows asks, Rows bids) {
this.time = time;
this.asks = asks;
this.bids = bids;
}
@Override
public String to() {
return '{' +
"\"time\":" + Util.to(this.time) +
",\"asks\":" + Util.to(this.asks) +
",\"bids\":" + Util.to(this.bids) +
'}';
}
public static Depth of(String data, Logger log) {
try {
JSONObject r = JSON.parseObject(data);
return new Depth(
r.getLong("time"),
Rows.of(r.getJSONArray("asks"), log),
Rows.of(r.getJSONArray("bids"), log));
} catch (Exception e) {
e.printStackTrace();
log.error(e.getMessage());
log.error("of error -> {}", data);
}
return null;
}
}
| 1,596 | Java | .java | goaiquant/GOAi | 63 | 31 | 0 | 2019-02-25T10:14:13Z | 2019-12-10T13:02:33Z |
Kline.java | /FileExtraction/Java_unseen/goaiquant_GOAi/engine/model/src/main/java/cqt/goai/model/market/Kline.java | package cqt.goai.model.market;
import com.alibaba.fastjson.JSONArray;
import cqt.goai.model.To;
import cqt.goai.model.Util;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.ToString;
import org.slf4j.Logger;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Objects;
/**
* K线信息
* @author GOAi
*/
@Getter
@ToString
@EqualsAndHashCode
public class Kline implements To, Serializable {
private static final long serialVersionUID = 3739670180018865992L;
/**
* 交易所返回的原始数据, 防止有些用户需要一些特殊的数据
*/
private final String data;
/**
* 时间, 精确到秒
*/
private final Long time;
/**
* 开盘价
*/
private final BigDecimal open;
/**
* 最高价
*/
private final BigDecimal high;
/**
* 最低价
*/
private final BigDecimal low;
/**
* 收盘价
*/
private final BigDecimal close;
/**
* 交易量
*/
private final BigDecimal volume;
public Kline(String data, Long time, BigDecimal open, BigDecimal high,
BigDecimal low, BigDecimal close, BigDecimal volume) {
this.data = data;
this.time = time;
this.open = Util.strip(open);
this.high = Util.strip(high);
this.low = Util.strip(low);
this.close = Util.strip(close);
this.volume = Util.strip(volume);
}
@Override
public String to() {
return '[' +
Util.encode(this.data) +
',' + Util.to(this.time) +
',' + Util.to(this.open) +
',' + Util.to(this.high) +
',' + Util.to(this.low) +
',' + Util.to(this.close) +
',' + Util.to(this.volume) +
']';
}
public double open() {
Objects.requireNonNull(this.open);
return this.open.doubleValue();
}
public double high() {
Objects.requireNonNull(this.high);
return this.high.doubleValue();
}
public double low() {
Objects.requireNonNull(this.low);
return this.low.doubleValue();
}
public double close() {
Objects.requireNonNull(this.close);
return this.close.doubleValue();
}
public double volume() {
Objects.requireNonNull(this.volume);
return this.volume.doubleValue();
}
public static Kline of(String data, Logger log) {
return Util.of(data, Kline::of, log);
}
static Kline of(JSONArray r) {
return new Kline(
Util.decode(r.getString(0)),
r.getLong(1),
r.getBigDecimal(2),
r.getBigDecimal(3),
r.getBigDecimal(4),
r.getBigDecimal(5),
r.getBigDecimal(6));
}
}
| 2,879 | Java | .java | goaiquant/GOAi | 63 | 31 | 0 | 2019-02-25T10:14:13Z | 2019-12-10T13:02:33Z |
Trades.java | /FileExtraction/Java_unseen/goaiquant_GOAi/engine/model/src/main/java/cqt/goai/model/market/Trades.java | package cqt.goai.model.market;
import cqt.goai.model.BaseModelList;
import cqt.goai.model.Util;
import org.slf4j.Logger;
import java.io.Serializable;
import java.util.List;
/**
* 多个成交信息
* @author GOAi
*/
public class Trades extends BaseModelList<Trade> implements Serializable {
private static final long serialVersionUID = -5998165404968198947L;
public Trades(List<Trade> list) {
super(list);
}
public static Trades of(String data, Logger log) {
return Util.of(data, Trades::new, Trade::of, log);
}
@Override
public String toString() {
return "Trades" + super.toString();
}
}
| 656 | Java | .java | goaiquant/GOAi | 63 | 31 | 0 | 2019-02-25T10:14:13Z | 2019-12-10T13:02:33Z |
Row.java | /FileExtraction/Java_unseen/goaiquant_GOAi/engine/model/src/main/java/cqt/goai/model/market/Row.java | package cqt.goai.model.market;
import com.alibaba.fastjson.JSONArray;
import cqt.goai.model.To;
import cqt.goai.model.Util;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.ToString;
import org.slf4j.Logger;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Objects;
/**
* 档位 价格 和 数量
* @author GOAi
*/
@Getter
@ToString
@EqualsAndHashCode
public class Row implements To, Serializable {
private static final long serialVersionUID = -5070260547441227713L;
/**
* 交易所返回的原始数据, 防止有些用户需要一些特殊的数据
*/
private final String data;
/**
* 价格
*/
private final BigDecimal price;
/**
* 数量
*/
private final BigDecimal amount;
public Row(String data, BigDecimal price, BigDecimal amount) {
this.data = data;
this.price = Util.strip(price);
this.amount = Util.strip(amount);
}
@Override
public String to() {
return '[' +
Util.encode(this.data) +
',' + Util.to(this.price) +
',' + Util.to(this.amount) +
']';
}
public double price() {
Objects.requireNonNull(this.price);
return this.price.doubleValue();
}
public double amount() {
Objects.requireNonNull(this.amount);
return this.amount.doubleValue();
}
public static Row of(String data, Logger log) {
return Util.of(data, Row::of, log);
}
static Row of(JSONArray r) {
return new Row(
Util.decode(r.getString(0)),
r.getBigDecimal(1),
r.getBigDecimal(2));
}
public static Row row(BigDecimal price, BigDecimal amount) {
return new Row(null, price, amount);
}
}
| 1,840 | Java | .java | goaiquant/GOAi | 63 | 31 | 0 | 2019-02-25T10:14:13Z | 2019-12-10T13:02:33Z |
Rows.java | /FileExtraction/Java_unseen/goaiquant_GOAi/engine/model/src/main/java/cqt/goai/model/market/Rows.java | package cqt.goai.model.market;
import com.alibaba.fastjson.JSONArray;
import cqt.goai.model.BaseModelList;
import cqt.goai.model.Util;
import org.slf4j.Logger;
import java.io.Serializable;
import java.util.List;
/**
* 多个档位
* @author GOAi
*/
public class Rows extends BaseModelList<Row> implements Serializable {
private static final long serialVersionUID = -7432880663696816431L;
public Rows(List<Row> list) {
super(list);
}
public static Rows of(String data, Logger log) {
return Util.of(data, Rows::new, Row::of, log);
}
static Rows of(JSONArray r, Logger log) {
return Util.of(r, Rows::new, Row::of, log);
}
@Override
public String toString() {
return "Rows" + super.toString();
}
}
| 778 | Java | .java | goaiquant/GOAi | 63 | 31 | 0 | 2019-02-25T10:14:13Z | 2019-12-10T13:02:33Z |
Klines.java | /FileExtraction/Java_unseen/goaiquant_GOAi/engine/model/src/main/java/cqt/goai/model/market/Klines.java | package cqt.goai.model.market;
import cqt.goai.model.BaseModelList;
import cqt.goai.model.Util;
import org.slf4j.Logger;
import java.io.Serializable;
import java.util.List;
/**
* 多根K线，按时间顺序由近到远 get(0)是最近的K线
* @author GOAi
*/
public class Klines extends BaseModelList<Kline> implements Serializable {
private static final long serialVersionUID = 3954815101761999805L;
public Klines(List<Kline> list) {
super(list);
}
public static Klines of(String data, Logger log) {
return Util.of(data, Klines::new, Kline::of, log);
}
@Override
public String toString() {
return "Klines" + super.toString();
}
}
| 699 | Java | .java | goaiquant/GOAi | 63 | 31 | 0 | 2019-02-25T10:14:13Z | 2019-12-10T13:02:33Z |
Ticker.java | /FileExtraction/Java_unseen/goaiquant_GOAi/engine/model/src/main/java/cqt/goai/model/market/Ticker.java | package cqt.goai.model.market;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import cqt.goai.model.To;
import cqt.goai.model.Util;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.ToString;
import org.slf4j.Logger;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Objects;
/**
* Ticker信息
*
* Prototype Pattern 原型模式
* 本来想用原型模式，每个推送都clone一份
* 最后决定还是用不可变类，这样并发更好
*
* @author GOAi
*/
@Getter
@ToString
@EqualsAndHashCode
public class Ticker implements To, Serializable {
private static final long serialVersionUID = 8856908960657104056L;
/**
* 交易所返回的原始数据, 防止有些用户需要一些特殊的数据
*/
private final String data;
/**
* 时间戳
*/
private final Long time;
/**
* 开盘价
*/
private final BigDecimal open;
/**
* 最高价
*/
private final BigDecimal high;
/**
* 最低价
*/
private final BigDecimal low;
/**
* 收盘价
*/
private final BigDecimal last;
/**
* 交易量
*/
private final BigDecimal volume;
public Ticker(String data, Long time, BigDecimal open, BigDecimal high,
BigDecimal low, BigDecimal last, BigDecimal volume) {
this.data = data;
this.time = time;
this.open = Util.strip(open);
this.high = Util.strip(high);
this.low = Util.strip(low);
this.last = Util.strip(last);
this.volume = Util.strip(volume);
}
@Override
public String to() {
return '{' +
"\"data\":" + Util.encode(this.data) +
",\"time\":" + Util.to(this.time) +
",\"open\":" + Util.to(this.open) +
",\"high\":" + Util.to(this.high) +
",\"low\":" + Util.to(this.low) +
",\"last\":" + Util.to(this.last) +
",\"volume\":" + Util.to(this.volume) +
'}';
}
public double open() {
Objects.requireNonNull(this.open);
return this.open.doubleValue();
}
public double high() {
Objects.requireNonNull(this.high);
return this.high.doubleValue();
}
public double low() {
Objects.requireNonNull(this.low);
return this.low.doubleValue();
}
public double last() {
Objects.requireNonNull(this.last);
return this.last.doubleValue();
}
public double volume() {
Objects.requireNonNull(this.volume);
return this.volume.doubleValue();
}
public static Ticker of(String data, Logger log) {
try {
JSONObject r = JSON.parseObject(data);
return new Ticker(
Util.decode(r.getString("data")),
r.getLong("time"),
r.getBigDecimal("open"),
r.getBigDecimal("high"),
r.getBigDecimal("low"),
r.getBigDecimal("last"),
r.getBigDecimal("volume"));
} catch (Exception e) {
e.printStackTrace();
log.error(e.getMessage());
log.error("of error -> {}", data);
}
return null;
}
}
| 3,353 | Java | .java | goaiquant/GOAi | 63 | 31 | 0 | 2019-02-25T10:14:13Z | 2019-12-10T13:02:33Z |
Main.java | /FileExtraction/Java_unseen/goaiquant_GOAi/strategy/src/main/java/Main.java | /**
* 启动类
*
* @author GOAi
*/
public class Main {
public static void main(String[] args) {
cqt.goai.run.Application.main(args);
}
}
| 160 | Java | .java | goaiquant/GOAi | 63 | 31 | 0 | 2019-02-25T10:14:13Z | 2019-12-10T13:02:33Z |
Demo.java | /FileExtraction/Java_unseen/goaiquant_GOAi/strategy/src/main/java/Demo.java | import cqt.goai.model.market.Ticker;
import cqt.goai.run.main.RunTask;
import static dive.common.util.Util.exist;
/**
* 演示类 演示HTTP调用的基础使用方法
* @author GOAi
*/
public class Demo extends RunTask {
/**
* 以下配置对应 config.yml 中的配置名 如需使用请先定义好 引擎会自动赋值
*/
private String myString;
/**
* 在这里可以完成策略初始化的工作
*/
@Override
protected void init() {
log.info("myString --> {}",myString);
}
/**
* 默认一秒执行一次该函数 可在配置表中配置loop字段 指定时间
*/
@Override
protected void loop() {
Ticker ticker = e.getTicker(true);
log.info("exchange name --> {} ticker last: {}", e.getName(), exist(ticker) ? ticker.getLast() : null);
}
/**
* 程序关闭的时候调用
*/
@Override
protected void destroy() {
log.info(id + " destroy");
}
}
| 988 | Java | .java | goaiquant/GOAi | 63 | 31 | 0 | 2019-02-25T10:14:13Z | 2019-12-10T13:02:33Z |
Tutorial02.java | /FileExtraction/Java_unseen/goaiquant_GOAi/strategy/src/main/java/tutorial/Tutorial02.java | package tutorial;
import cqt.goai.model.market.Ticker;
import cqt.goai.run.main.RunTask;
import static dive.common.util.Util.exist;
/**
* 教程2：本教程你将了解 如何进行策略的配置。
* 配置策略参数的两种方式：1、会优先在线获取配置：通过GOAi后台配置策略对应参数的值，并在策略中定义该变量名
* 引擎启动后会自动把线上参数的值赋值给同名变量。
* 2、如果线上配置获取不成功或本地调试的时候会从本地的resources目录下的 config.yml 中获取参数值并赋值给策略中
* 定义好的变量。
* config.yml 配置信息中
* strategy_name：是该策略的名称 可以任意取。
* class_name：是你策略的全类名。例如该教程 class_name: 'tutorial.Tutorial02'
* configs: configs下定义好策略配置需要的参数。除 loop、e、telegramToken、telegramGroup
* 外的变量名须在策略中定义好同名变量引擎才会自动赋值。
* 例如：loop: 0.5 指定了loop 函数0.5秒执行一次
* 交易所的配置方式可以参照yml 文件。因okexv3交易所密钥多了一个字段 需在公钥后加 下划线指定。
*/
public class Tutorial02 extends RunTask {
/**
* 以下配置对应 config.yml 中的配置名 如需使用请先定义好 引擎会自动赋值
*/
private String myString;
@Override
protected void init() {
log.info("打印了config.yml 中配置的变量 myString：{}",myString);
log.info("loop函数获取了交易所的Ticker 如网络无法连接 等待几秒后会有错误信息 connect timed out");
}
@Override
protected void loop() {
Ticker ticker = e.getTicker();
log.info("exchange name --> {} ticker last: {}", e.getName(), exist(ticker) ? ticker.getLast() : null);
}
}
| 1,948 | Java | .java | goaiquant/GOAi | 63 | 31 | 0 | 2019-02-25T10:14:13Z | 2019-12-10T13:02:33Z |
Tutorial03.java | /FileExtraction/Java_unseen/goaiquant_GOAi/strategy/src/main/java/tutorial/Tutorial03.java | package tutorial;
import cqt.goai.run.main.RunTask;
import cqt.goai.run.notice.NoticeType;
import java.util.Arrays;
/**
* 教程2：本教程你将了解 如何通知 和 持久化信息。
*/
public class Tutorial03 extends RunTask {
@Override
protected void init() {
notice.noticeLow("low notice");
notice.noticeHigh("high notice");
notice.noticeHigh("high notice email", NoticeType.Email);
notice.noticeHigh("high notice telegram", NoticeType.Telegram);
// 1 全局存储和读取信息
global("test1", 123);
int value1 = global("test1");
// 2 实时显示信息
// 显示字符串
show("show string");
// 显示表格
show("show table", Arrays.asList("标题1", "标题2"),
Arrays.asList("行11", "行12"),
Arrays.asList("行21", "行22"));
// 3 存储收益，显示收益曲线
profit(1234);
}
}
| 970 | Java | .java | goaiquant/GOAi | 63 | 31 | 0 | 2019-02-25T10:14:13Z | 2019-12-10T13:02:33Z |
Tutorial01.java | /FileExtraction/Java_unseen/goaiquant_GOAi/strategy/src/main/java/tutorial/Tutorial01.java | package tutorial;
import cqt.goai.run.main.RunTask;
/**
* 教程1： 本教程你将了解 1、你的策略类需继承的父类。2、策略基础的三个方法
* 1、GOAi引擎会封装好 运行策略的相关工作。你只需新建好你的策略类 并继承RunRask即可。
* 2、有三个基础函数可能需要重写 init()、loop()、destroy() 。
* init()顾名思义负责做初始化的工作。如果你的策略没有需要做的准备工作则无需重写该函数。
* loop()你的策略逻辑在该函数中实现。函数默认1秒引擎会调用一次，如需更改请在配置中指定loop的值。
* destroy() 策略关闭前会调用一次，如你的策略无需做收尾工作则不用重写该函数。
*/
public class Tutorial01 extends RunTask {
/**
* 在这里可以完成策略初始化的工作
*/
@Override
protected void init() {
log.info("Hello GOAi! 在这里可以完成你的策略的准备工作。");
}
/**
* 默认一秒执行一次该函数 可在配置表中配置loop字段 指定时间 例如0.5 为每半秒执行一次。
*/
@Override
protected void loop() {
log.info("该函数固定时间会调用一次。在这里写你的策略逻辑吧 就是这么简单！");
}
/**
* 程序关闭的时候调用
*/
@Override
protected void destroy() {
log.info("在这里处理你策略关闭的时候需要做的收尾工作，仅执行一次。");
}
}
| 1,561 | Java | .java | goaiquant/GOAi | 63 | 31 | 0 | 2019-02-25T10:14:13Z | 2019-12-10T13:02:33Z |
Tutorial04.java | /FileExtraction/Java_unseen/goaiquant_GOAi/strategy/src/main/java/tutorial/Tutorial04.java | package tutorial;
import cqt.goai.exchange.util.RateLimit;
import cqt.goai.model.market.Ticker;
import cqt.goai.run.exchange.Exchange;
import cqt.goai.run.main.RunTask;
import cqt.goai.run.notice.NoticeType;
import java.util.Arrays;
/**
* 教程2：本教程你将了解 如何接受主动推送信息。
* onTicker 主动推送ticker
* onKlines 主动推送klines
* onDepth 主动推送depth
* onTrades 主动推送trades
* onAccount 主动推送account
* onOrders 主动推送orders
*
* 以ticker为例，2种推送方式：
* 1. 名为 属性名OnTicker(Ticker ticker) 的方法
* 2. 调用对应Exchange的setOnTicker(Consumer<Ticker> consumer[, RateLimit limit])方法,
* 该方法可限制推送频率不高于某个秒数, RateLimit.limit(mills) 或使用默认的 RateLimit.second3()等
*
*/
public class Tutorial04 extends RunTask {
/**
* 有这个Exchange才会有推送
*/
private Exchange huobiE;
@Override
protected void init() {
// 这种方式设置的主动推送，可以设置间隔时间，例：second3 表明两次推送的最小间隔不超过3秒
huobiE.setOnTicker(ticker -> {
log.info("huobi e 2 ticker -> {}", ticker);
}, RateLimit.second3());
}
/**
* 属于参数 huobiE 的主动推送，
* 以 huobiE 开头，并且只有一个Ticker参数的方法会默认设置推送
* @param ticker
*/
protected void huobiEOnTicker(Ticker ticker) {
log.info("huobi e 1 ticker -> {}", ticker);
}
/**
* 默认为 e 的主动推送
* @param ticker
*/
@Override
protected void onTicker(Ticker ticker) {
log.info("e ticker -> {}", ticker);
}
}
| 1,784 | Java | .java | goaiquant/GOAi | 63 | 31 | 0 | 2019-02-25T10:14:13Z | 2019-12-10T13:02:33Z |
MainDriver.java | /FileExtraction/Java_unseen/mirajp1_java2plantuml/src/main/java/MainDriver.java | import source.DirectoryExplorer;
import source.FileHandler;
import translate.ClassDiagramConfig;
import translate.UmlTranslator;
import visitors.ClassVisitor;
import visitors.EnumVisitor;
import visitors.InterfaceVisitor;
import java.io.File;
import java.io.FileOutputStream;
public class MainDriver {
public static void main(String[] args){
String sourcePath="src/main/java/";
if(args.length<1){
System.out.println("Need to pass path of source as argument");
System.exit(1);
}
for(int i=0;i<args.length;){
switch (args[i]){
default:
System.out.println(args[i]);
sourcePath=args[i];
i++;
break;
}
}
try {
UmlTranslator umlTranslator=new UmlTranslator();
ClassDiagramConfig config= new ClassDiagramConfig.Builder()
.withVisitor(new ClassVisitor(umlTranslator))
.withVisitor(new InterfaceVisitor(umlTranslator))
.withVisitor(new EnumVisitor(umlTranslator))
.setShowMethods(true)
.setShowAttributes(true)
.setShowColoredAccessSpecifiers(false)
.build();
umlTranslator.setConfig(config);
FileHandler handler = new FileHandler(umlTranslator);
File resourceDir = new File(sourcePath);
if(resourceDir.exists()){
new DirectoryExplorer(handler).explore(resourceDir);
}
else{
System.out.println("File/Folder doesn't exist!");
System.exit(1);
}
File f = new File("output.puml");
FileOutputStream fos = new FileOutputStream(f);
fos.write(umlTranslator.toPlantUml().getBytes());
fos.close();
System.out.println("PlantUml syntax generated in output file.");
} catch (Exception e) {
e.printStackTrace();
}
}
}
| 2,098 | Java | .java | mirajp1/java2plantuml | 14 | 6 | 0 | 2017-12-25T20:48:43Z | 2017-12-25T21:04:13Z |
ClassVisitor.java | /FileExtraction/Java_unseen/mirajp1_java2plantuml/src/main/java/visitors/ClassVisitor.java | package visitors;
import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
import com.github.javaparser.ast.visitor.VoidVisitorAdapter;
import translate.Translator;
public class ClassVisitor extends VoidVisitorAdapter<Void> {
private Translator translator;
public ClassVisitor(Translator translator){
this.translator=translator;
}
@Override
public void visit(ClassOrInterfaceDeclaration n, Void arg) {
if(!n.isInterface()) {
this.translator.addClass(n);
// System.out.println(n.getName());
}
super.visit(n, arg);
}
}
| 613 | Java | .java | mirajp1/java2plantuml | 14 | 6 | 0 | 2017-12-25T20:48:43Z | 2017-12-25T21:04:13Z |
EnumVisitor.java | /FileExtraction/Java_unseen/mirajp1_java2plantuml/src/main/java/visitors/EnumVisitor.java | package visitors;
import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
import com.github.javaparser.ast.body.EnumDeclaration;
import com.github.javaparser.ast.visitor.VoidVisitorAdapter;
import translate.Translator;
public class EnumVisitor extends VoidVisitorAdapter<Void> {
private Translator translator;
public EnumVisitor(Translator translator){
this.translator=translator;
}
@Override
public void visit(EnumDeclaration n, Void arg) {
this.translator.addEnum(n);
super.visit(n, arg);
}
}
| 561 | Java | .java | mirajp1/java2plantuml | 14 | 6 | 0 | 2017-12-25T20:48:43Z | 2017-12-25T21:04:13Z |
InterfaceVisitor.java | /FileExtraction/Java_unseen/mirajp1_java2plantuml/src/main/java/visitors/InterfaceVisitor.java | package visitors;
import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
import com.github.javaparser.ast.visitor.VoidVisitorAdapter;
import translate.Translator;
public class InterfaceVisitor extends VoidVisitorAdapter<Void> {
private Translator translator;
public InterfaceVisitor(Translator translator){
this.translator=translator;
}
@Override
public void visit(ClassOrInterfaceDeclaration n, Void arg) {
if(n.isInterface()) {
this.translator.addInterface(n);
}
super.visit(n, arg);
}
}
| 577 | Java | .java | mirajp1/java2plantuml | 14 | 6 | 0 | 2017-12-25T20:48:43Z | 2017-12-25T21:04:13Z |
Translator.java | /FileExtraction/Java_unseen/mirajp1_java2plantuml/src/main/java/translate/Translator.java | package translate;
import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
import com.github.javaparser.ast.body.EnumDeclaration;
import com.github.javaparser.ast.body.FieldDeclaration;
import com.github.javaparser.ast.body.MethodDeclaration;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.Serializable;
public interface Translator{
public void addClass(ClassOrInterfaceDeclaration c);
public void addEnum(EnumDeclaration c);
public void addInterface(ClassOrInterfaceDeclaration i);
public void addField(FieldDeclaration f);
public void addMethod(MethodDeclaration d);
public void setError(Boolean b);
public void translateFile(File f) throws FileNotFoundException;
} | 738 | Java | .java | mirajp1/java2plantuml | 14 | 6 | 0 | 2017-12-25T20:48:43Z | 2017-12-25T21:04:13Z |
UmlTranslator.java | /FileExtraction/Java_unseen/mirajp1_java2plantuml/src/main/java/translate/UmlTranslator.java | package translate;
import com.github.javaparser.JavaParser;
import com.github.javaparser.ast.CompilationUnit;
import com.github.javaparser.ast.Modifier;
import com.github.javaparser.ast.body.*;
import com.github.javaparser.ast.type.ClassOrInterfaceType;
import com.github.javaparser.ast.visitor.VoidVisitorAdapter;
import java.io.File;
import java.io.FileNotFoundException;
import java.util.EnumSet;
import java.util.HashSet;
import java.util.Set;
public class UmlTranslator implements Translator {
private Set<ClassOrInterfaceDeclaration> classSet;
private Set<ClassOrInterfaceDeclaration> interfaceSet;
private Set<EnumDeclaration> enumSet;
private Boolean error=false;
private ClassDiagramConfig config=new ClassDiagramConfig.DefaultDirector().construct();
public UmlTranslator(){
classSet=new HashSet<>();
interfaceSet=new HashSet<>();
enumSet=new HashSet<>();
}
public void setConfig(ClassDiagramConfig config) {
this.config = config;
}
@Override
public void addClass(ClassOrInterfaceDeclaration c) {
if(!c.isInterface())
classSet.add(c);
}
@Override
public void addEnum(EnumDeclaration e) {
enumSet.add(e);
}
@Override
public void addInterface(ClassOrInterfaceDeclaration i) {
if(i.isInterface())
interfaceSet.add(i);
}
@Override
public void addField(FieldDeclaration f) {
}
@Override
public void addMethod(MethodDeclaration d) {
}
@Override
public void setError(Boolean b) {
this.error=b;
}
@Override
public void translateFile(File f) {
CompilationUnit cu = null;
try {
cu = JavaParser.parse(new File(f.getAbsolutePath()));
for(VoidVisitorAdapter<Void> visitor:config.getVisitorAdapters()){
cu.accept(visitor,null);
}
} catch (Exception e) {
setError(true);
e.printStackTrace();
}
}
public String toPlantUml(){
StringBuilder sb = new StringBuilder();
if(error){
sb.append("Error occured while parsing.");
return sb.toString();
}
sb.append("@startuml");
sb.append("\n");
//this is for removing shapes in attributes/methods visibility
if(!config.isShowColoredAccessSpecifiers())
sb.append("skinparam classAttributeIconSize 0\n");
writeClasses(sb);
writeAssociations(sb);
writeInterfaces(sb);
writeEnumerations(sb);
sb.append("@enduml");
return sb.toString();
}
private void writeAssociations(StringBuilder sb) {
HashSet<String> temp = new HashSet<>();
for(ClassOrInterfaceDeclaration c: classSet){
temp.add(c.getNameAsString());
}
for(ClassOrInterfaceDeclaration c: interfaceSet){
temp.add(c.getNameAsString());
}
for (EnumDeclaration e:enumSet){
temp.add(e.getNameAsString());
}
for(ClassOrInterfaceDeclaration c: classSet){
for(FieldDeclaration f: c.getFields()){
if(temp.contains(f.getVariables().get(0).getType().asString())){
sb.append(c.getName().asString());
sb.append("--");
// sb.append("\"-");
sb.append("\"");
writeModifiers(f.getModifiers(),sb);
sb.append(f.getVariables().get(0).getName());
sb.append("\" ");
sb.append(f.getVariables().get(0).getType().asString());
sb.append("\n");
}
}
}
}
private void writeClasses(StringBuilder sb){
for(ClassOrInterfaceDeclaration c: classSet){
writeClass(c,sb);
}
}
private void writeClass(ClassOrInterfaceDeclaration c,StringBuilder sb) {
sb.append("class ");
sb.append(c.getName());
sb.append("{");
sb.append("\n");
// for(ClassOrInterfaceDeclaration c1:c.get)
//attributes
if (config.isShowAttributes()){
writeAttributes(c, sb);
}
if(config.isShowMethods()) {
//methods
writeConstructors(c,sb);
writeMethods(c, sb);
}
sb.append("}\n");
//implemented interfaces
for(ClassOrInterfaceType e: c.getImplementedTypes()){
sb.append(c.getName());
sb.append(" ..|> ");
sb.append(e.getName());
sb.append("\n");
}
//extended classes
for(ClassOrInterfaceType e: c.getExtendedTypes()){
sb.append(c.getName());
sb.append(" --|> ");
sb.append(e.getName());
sb.append("\n");
}
}
private void writeAttributes(ClassOrInterfaceDeclaration c, StringBuilder sb) {
for(FieldDeclaration f : c.getFields()){
writeField(f,sb);
sb.append("\n");
}
}
private void writeField(FieldDeclaration f, StringBuilder sb) {
writeModifiers(f.getModifiers(),sb);
sb.append(f.getVariables().get(0).getName());
sb.append(" : ");
sb.append(f.getVariables().get(0).getType().asString());
}
private void writeConstructors(ClassOrInterfaceDeclaration c, StringBuilder sb) {
for(ConstructorDeclaration m: c.getConstructors()){
writeConstructor(m,sb);
sb.append("\n");
}
}
private void writeConstructor(ConstructorDeclaration m, StringBuilder sb) {
writeModifiers(m.getModifiers(),sb);
sb.append(m.getName());
sb.append("(");
for(Parameter p: m.getParameters()){
sb.append(p.getName());
sb.append(" : ");
sb.append(p.getType().asString());
sb.append(", ");
}
if(m.getParameters().size()>0){
sb.deleteCharAt(sb.length()-1);
sb.deleteCharAt(sb.length()-1);
}
sb.append(")");
// sb.append(" : ");
// sb.append(m.getType().asString());
}
private void writeMethods(ClassOrInterfaceDeclaration c, StringBuilder sb) {
for(MethodDeclaration m: c.getMethods()){
writeMethod(m,sb);
sb.append("\n");
}
}
private void writeMethod(MethodDeclaration m, StringBuilder sb) {
writeModifiers(m.getModifiers(),sb);
sb.append(m.getName());
sb.append("(");
for(Parameter p: m.getParameters()){
sb.append(p.getName());
sb.append(" : ");
sb.append(p.getType().asString());
sb.append(", ");
}
if(m.getParameters().size()>0){
sb.deleteCharAt(sb.length()-1);
sb.deleteCharAt(sb.length()-1);
}
sb.append(")");
sb.append(" : ");
sb.append(m.getType().asString());
}
private void writeModifiers(EnumSet<Modifier> modifiers, StringBuilder sb) {
for(Modifier mod:modifiers){
switch (mod){
case STATIC:
sb.append("{static} ");
break;
case ABSTRACT:
sb.append("{abstract} ");
break;
case PUBLIC:
sb.append("+ ");
break;
case PRIVATE:
sb.append("- ");
break;
case PROTECTED:
sb.append("# ");
break;
//TODO:package visibility not shown yet
case DEFAULT:
sb.append("~ ");
break;
}
}
}
private void writeEnumerations(StringBuilder sb){
for(EnumDeclaration e: enumSet){
sb.append("enum ");
sb.append(e.getName());
sb.append("{\n");
for(EnumConstantDeclaration c: e.getEntries()){
sb.append(c.getName());
sb.append("\n");
}
sb.append("}\n");
}
}
// private void writeInterfaces(StringBuilder sb){
//
// for(ClassOrInterfaceDeclaration i: interfaceSet){
// sb.append("interface ");
// sb.append(i.getName());
// sb.append("\n");
//
// for(ClassOrInterfaceType e: i.getExtendedTypes()){
//
// sb.append(i.getName());
// sb.append(" --|> ");
// sb.append(e.getName());
// sb.append("\n");
// }
//
// }
//
// }
private void writeInterfaces(StringBuilder sb){
for(ClassOrInterfaceDeclaration c: interfaceSet){
writeInterface(c,sb);
}
}
private void writeInterface(ClassOrInterfaceDeclaration c,StringBuilder sb) {
sb.append("interface ");
sb.append(c.getName());
sb.append("{");
sb.append("\n");
// for(ClassOrInterfaceDeclaration c1:c.get)
//attributes
if (config.isShowAttributes()){
writeAttributes(c, sb);
}
if(config.isShowMethods()) {
//methods
writeConstructors(c,sb);
writeMethods(c, sb);
}
sb.append("}\n");
for(ClassOrInterfaceType e: c.getExtendedTypes()){
sb.append(c.getName());
sb.append(" --|> ");
sb.append(e.getName());
sb.append("\n");
}
}
}
| 9,702 | Java | .java | mirajp1/java2plantuml | 14 | 6 | 0 | 2017-12-25T20:48:43Z | 2017-12-25T21:04:13Z |
ClassDiagramConfig.java | /FileExtraction/Java_unseen/mirajp1_java2plantuml/src/main/java/translate/ClassDiagramConfig.java | package translate;
import com.github.javaparser.ast.visitor.VoidVisitorAdapter;
import java.util.ArrayList;
import java.util.List;
public class ClassDiagramConfig {
private List<VoidVisitorAdapter<Void>> visitorAdapters;
private boolean showMethods;
private boolean showAttributes;
private boolean showColoredAccessSpecifiers;
//private constructor, use builder only
private ClassDiagramConfig(){};
public List<VoidVisitorAdapter<Void>> getVisitorAdapters() {
return visitorAdapters;
}
public void setVisitorAdapters(List<VoidVisitorAdapter<Void>> visitorAdapters) {
this.visitorAdapters = visitorAdapters;
}
public boolean isShowMethods() {
return showMethods;
}
public void setShowMethods(boolean showMethods) {
this.showMethods = showMethods;
}
public boolean isShowAttributes() {
return showAttributes;
}
public void setShowAttributes(boolean showAttributes) {
this.showAttributes = showAttributes;
}
public boolean isShowColoredAccessSpecifiers() {
return showColoredAccessSpecifiers;
}
public void setShowColoredAccessSpecifiers(boolean showColoredAccessSpecifiers) {
this.showColoredAccessSpecifiers = showColoredAccessSpecifiers;
}
//builder
public static class Builder implements UmlConfigBuilder{
//default values for attributes
private List<VoidVisitorAdapter<Void>> visitorAdapters=new ArrayList<>();
private boolean showMethods=true;
private boolean showAttributes=true;
private boolean showColoredAccessSpecifiers=false;
public Builder withVisitor(VoidVisitorAdapter<Void> visitor){
visitorAdapters.add(visitor);
return this;
}
public Builder setShowMethods(boolean showMethods){
this.showMethods=showMethods;
return this;
}
public Builder setShowAttributes(boolean showAttributes){
this.showAttributes=showAttributes;
return this;
}
public Builder setShowColoredAccessSpecifiers(boolean showColoredAccessSpecifiers){
this.showColoredAccessSpecifiers=showColoredAccessSpecifiers;
return this;
}
@Override
public ClassDiagramConfig build() {
ClassDiagramConfig config=new ClassDiagramConfig();
config.setVisitorAdapters(visitorAdapters);
config.setShowAttributes(showAttributes);
config.setShowColoredAccessSpecifiers(showColoredAccessSpecifiers);
config.setShowMethods(showMethods);
return config;
}
}
//default director for builder
public static class DefaultDirector{
public ClassDiagramConfig construct(){
return new Builder().build();
}
}
}
| 2,885 | Java | .java | mirajp1/java2plantuml | 14 | 6 | 0 | 2017-12-25T20:48:43Z | 2017-12-25T21:04:13Z |
UmlConfigBuilder.java | /FileExtraction/Java_unseen/mirajp1_java2plantuml/src/main/java/translate/UmlConfigBuilder.java | package translate;
public interface UmlConfigBuilder {
public ClassDiagramConfig build();
}
| 99 | Java | .java | mirajp1/java2plantuml | 14 | 6 | 0 | 2017-12-25T20:48:43Z | 2017-12-25T21:04:13Z |
FileHandler.java | /FileExtraction/Java_unseen/mirajp1_java2plantuml/src/main/java/source/FileHandler.java | package source;
import com.github.javaparser.ast.CompilationUnit;
import translate.Translator;
import java.io.File;
import java.io.FileNotFoundException;
public class FileHandler {
private Translator translator;
public FileHandler(Translator translator){
this.translator=translator;
}
void handle(File f){
System.out.println("File Found: " +f.getName());
CompilationUnit cu = null;
try {
translator.translateFile(new File(f.getAbsolutePath()));
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (Exception e){
translator.setError(true);
}
}
}
| 683 | Java | .java | mirajp1/java2plantuml | 14 | 6 | 0 | 2017-12-25T20:48:43Z | 2017-12-25T21:04:13Z |
DirectoryExplorer.java | /FileExtraction/Java_unseen/mirajp1_java2plantuml/src/main/java/source/DirectoryExplorer.java | package source;
import java.io.File;
import java.io.FileFilter;
public class DirectoryExplorer {
private FileHandler fileHandler;
public DirectoryExplorer (FileHandler fileHandler){
this.fileHandler=fileHandler;
}
FileFilter fileFilter = new FileFilter() {
@Override
public boolean accept(File pathname) {
return pathname.toString().endsWith(".java");
}
};
public void explore(File file){
if(file.isDirectory()){
for(File f : file.listFiles(fileFilter)){
explore(f);
}
for(File f:file.listFiles()){
if(f.isDirectory()){
explore(f);
}
}
}
else{
fileHandler.handle(file);
}
}
}
| 822 | Java | .java | mirajp1/java2plantuml | 14 | 6 | 0 | 2017-12-25T20:48:43Z | 2017-12-25T21:04:13Z |
RestMessagingException.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-messaging/hogajama-messaging-rest/src/main/java/com/gepardec/hogarama/messaging/RestMessagingException.java | package com.gepardec.hogarama.messaging;
public class RestMessagingException extends RuntimeException {
public RestMessagingException(Throwable cause) {
super(cause);
}
}
| 188 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
SensorDataMessagingRestEndpoint.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-messaging/hogajama-messaging-rest/src/main/java/com/gepardec/hogarama/messaging/SensorDataMessagingRestEndpoint.java | package com.gepardec.hogarama.messaging;
import com.gepardec.hogarama.domain.sensor.SensorData;
import jakarta.ws.rs.Consumes;
import jakarta.ws.rs.POST;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.core.MediaType;
import jakarta.ws.rs.core.Response;
@Path("/messaging/sensorData")
@Consumes(MediaType.APPLICATION_JSON)
@Produces(MediaType.TEXT_PLAIN)
public interface SensorDataMessagingRestEndpoint {
@POST
Response putMessage(SensorData sensorData);
} | 500 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
SensorDataMessagingRestEndpointImpl.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-messaging/hogajama-messaging-rest/src/main/java/com/gepardec/hogarama/messaging/SensorDataMessagingRestEndpointImpl.java | package com.gepardec.hogarama.messaging;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.ObjectWriter;
import com.gepardec.hogarama.domain.sensor.SensorData;
import com.gepardec.hogarama.domain.watering.WateringService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import jakarta.inject.Inject;
import jakarta.ws.rs.core.Response;
public class SensorDataMessagingRestEndpointImpl implements SensorDataMessagingRestEndpoint {
private static final Logger LOGGER = LoggerFactory.getLogger(SensorDataMessagingRestEndpointImpl.class);
@Inject
WateringService wateringService;
@Override
public Response putMessage(SensorData sensorData) {
ObjectWriter ow = new ObjectMapper().writer().withDefaultPrettyPrinter();
try {
String json = ow.writeValueAsString(sensorData);
LOGGER.info("Ongoing sensor data {}", json);
wateringService.processSensorData(sensorData);
} catch (Exception e) {
throw new RestMessagingException(e);
}
return Response.ok().build();
}
}
| 1,123 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
RestMessagingExceptionMapper.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-messaging/hogajama-messaging-rest/src/main/java/com/gepardec/hogarama/messaging/RestMessagingExceptionMapper.java | package com.gepardec.hogarama.messaging;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import jakarta.ws.rs.core.Response;
import jakarta.ws.rs.ext.ExceptionMapper;
import jakarta.ws.rs.ext.Provider;
import java.util.UUID;
@Provider
public class RestMessagingExceptionMapper implements ExceptionMapper<RestMessagingException> {
private static final Logger LOGGER = LoggerFactory.getLogger(RestMessagingExceptionMapper.class);
@Override
public Response toResponse(RestMessagingException e) {
UUID uuid = UUID.randomUUID();
LOGGER.error("Unexpected exception occurred {}", uuid, e);
String responseMessage = String.format("Unexpected exception occurred (ref %s)", uuid);
return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(responseMessage).build();
}
}
| 832 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
SensorDataMDB.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-messaging/hogajama-messaging-mdb/src/main/java/com/gepardec/hogarama/messaging/SensorDataMDB.java | package com.gepardec.hogarama.messaging;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.gepardec.hogarama.domain.sensor.SensorData;
import com.gepardec.hogarama.domain.watering.WateringService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import jakarta.ejb.ActivationConfigProperty;
import jakarta.ejb.MessageDriven;
import jakarta.inject.Inject;
import jakarta.jms.BytesMessage;
import jakarta.jms.JMSException;
import jakarta.jms.Message;
import jakarta.jms.MessageListener;
import java.io.IOException;
@MessageDriven(
activationConfig = {
@ActivationConfigProperty(propertyName = "destination", propertyValue = "habarama::watering"),
@ActivationConfigProperty(propertyName = "destinationType", propertyValue = "jakarta.jms.Queue"),
@ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge")
}
)
public class SensorDataMDB implements MessageListener {
private static final Logger log = LoggerFactory.getLogger(SensorDataMDB.class);
@Inject
WateringService wateringSvc;
public void onMessage(Message message) {
log.debug("Receive message of type " + message.getClass().getName());
BytesMessage msg = (BytesMessage) message;
try {
byte[] b = new byte[(int) msg.getBodyLength()];
msg.readBytes(b);
ObjectMapper mapper = new ObjectMapper();
SensorData sensorData = mapper.readValue(b, SensorData.class);
wateringSvc.processSensorData(sensorData);
} catch (JMSException | IOException e) {
throw new RuntimeException("Error handling sensor data!", e);
}
}
}
| 1,725 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
SensorDataKafkaEndpoint.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-messaging/hogajama-messaging-kafka/src/main/java/com/gepardec/hogarama/messaging/SensorDataKafkaEndpoint.java | package com.gepardec.hogarama.messaging;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.gepardec.hogarama.domain.DateUtils;
import com.gepardec.hogarama.domain.sensor.SensorData;
import com.gepardec.hogarama.domain.watering.WateringService;
import org.eclipse.microprofile.reactive.messaging.Incoming;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import jakarta.transaction.Transactional;
import java.io.IOException;
import java.time.LocalDateTime;
@ApplicationScoped
public class SensorDataKafkaEndpoint {
private static final Logger log = LoggerFactory.getLogger(SensorDataKafkaEndpoint.class);
@Inject
WateringService wateringSvc;
@Transactional
@Incoming("habarama-in")
public void onMessage(String message) {
log.info("Receive message from habarama-in: " + message);
try {
ObjectMapper mapper = new ObjectMapper();
SensorData sensorData = mapper.readValue(message, SensorData.class);
sensorData.setTime(DateUtils.toDate(LocalDateTime.now()));
wateringSvc.processSensorData(sensorData);
} catch (IOException e) {
throw new RuntimeException("Error handling sensor data!", e);
}
}
}
| 1,324 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
DummyUserProfileResolver.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-security-dummy/src/main/java/com/gepardec/hogarama/security/dummy/DummyUserProfileResolver.java | package com.gepardec.hogarama.security.dummy;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.gepardec.hogarama.domain.unitmanagement.entity.UserProfile;
import com.gepardec.hogarama.security.UserProfileResolver;
import jakarta.inject.Inject;
import jakarta.servlet.http.HttpServletRequest;
import java.util.Base64;
import java.util.Optional;
public class DummyUserProfileResolver implements UserProfileResolver {
@Inject
private HttpServletRequest request;
@Override
public UserProfile resolveUserProfile() {
UserProfile userProfile = Optional.ofNullable(extractFromRequest()).orElse(new UserProfile());
if (userProfile.getName() == null) {
userProfile.setName("Dummy");
}
if (userProfile.getEmail() == null) {
userProfile.setEmail("dummy@nowhere");
}
if (userProfile.getFamilyName() == null) {
userProfile.setFamilyName("Dummy");
}
if (userProfile.getGivenName() == null) {
userProfile.setGivenName("Franz");
}
return userProfile;
}
private UserProfile extractFromRequest() {
String authorization = request.getHeader("Authorization");
if (authorization == null || !authorization.contains("Dummy ")) {
return null;
}
String json = new String(Base64.getDecoder().decode(authorization.split("\\s")[1]));
ObjectMapper mapper = new ObjectMapper();
try {
return mapper.readValue(json, UserProfile.class);
} catch (JsonProcessingException e) {
return null;
}
}
}
| 1,700 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
JaxRsActivator.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-security-dummy/src/main/java/com/gepardec/hogarama/security/dummy/JaxRsActivator.java | package com.gepardec.hogarama.security.dummy;
import jakarta.ws.rs.ApplicationPath;
import jakarta.ws.rs.core.Application;
/**
* Activating JAX-RS annotation based.
*/
@ApplicationPath("/rest")
public class JaxRsActivator extends Application {
}
| 251 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
JwtUserProfileResolver.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-security-jwt/src/main/java/com/gepardec/hogarama/security/jwt/JwtUserProfileResolver.java | package com.gepardec.hogarama.security.jwt;
import com.gepardec.hogarama.domain.unitmanagement.entity.UserProfile;
import com.gepardec.hogarama.security.UserProfileResolver;
import org.eclipse.microprofile.jwt.Claims;
import org.eclipse.microprofile.jwt.JsonWebToken;
import jakarta.enterprise.inject.Default;
import jakarta.inject.Inject;
@Default
public class JwtUserProfileResolver implements UserProfileResolver {
@Inject
private JsonWebToken jwt;
@Override
public UserProfile resolveUserProfile() {
UserProfile userProfile = new UserProfile();
userProfile.setName(jwt.getClaim("name"));
userProfile.setEmail(jwt.getClaim(Claims.email));
userProfile.setFamilyName(jwt.getClaim(Claims.family_name));
userProfile.setGivenName(jwt.getClaim(Claims.given_name));
return userProfile;
}
}
| 861 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
JaxRsActivator.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-security-jwt/src/main/java/com/gepardec/hogarama/security/jwt/JaxRsActivator.java | package com.gepardec.hogarama.security.jwt;
import org.eclipse.microprofile.auth.LoginConfig;
import jakarta.ws.rs.ApplicationPath;
import jakarta.ws.rs.core.Application;
/**
* Activating JAX-RS annotation based.
*/
@ApplicationPath("/rest")
@LoginConfig(authMethod="MP-JWT", realmName="MP JWT Realm")
public class JaxRsActivator extends Application {
}
| 360 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
DummySensorDAO.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/test/java/com/gepardec/hogarama/dao/DummySensorDAO.java | package com.gepardec.hogarama.dao;
import java.util.Comparator;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;
import jakarta.enterprise.context.RequestScoped;
import jakarta.inject.Named;
import org.apache.commons.collections4.CollectionUtils;
import com.gepardec.hogarama.domain.sensor.SensorDataDAO;
import com.gepardec.hogarama.domain.sensor.SensorData;
import com.gepardec.hogarama.testdata.DummyData;
@Named("dummyHabaramaDao")
@RequestScoped
public class DummySensorDAO implements SensorDataDAO {
private static final int MAX_NUMBER_OF_SENSORS = 10;
private static final int MAX_NUMBER_OF_DATA = 10000;
private List<SensorData> sensorDatas;
public DummySensorDAO() {
super();
this.sensorDatas = DummyData.getDummySensorData(MAX_NUMBER_OF_SENSORS, MAX_NUMBER_OF_DATA, false);
}
public DummySensorDAO(List<SensorData> sensorDatas) {
super();
this.sensorDatas = sensorDatas;
}
@Override
public List<String> getAllSensors() {
return CollectionUtils.emptyIfNull(sensorDatas)
.stream()
.map(SensorData::getSensorName).distinct()
.collect(Collectors.toList());
}
@Override
public List<SensorData> getAllData(Integer maxNumber, String sensorName, Date from, Date to) {
Comparator<SensorData> comp = new Comparator<SensorData>() {
@Override
public int compare(SensorData o1, SensorData o2) {
return o1.getTime().compareTo(o2.getTime());
}
};
return CollectionUtils.emptyIfNull(sensorDatas)
.stream()
.filter(new SensorDataPredicate(sensorName, from, to))
.sorted(comp)
.collect(new LastNRecordCollector<>(maxNumber == null || maxNumber < 0 ? sensorDatas.size() : maxNumber));
}
@Override
public String getLocationBySensorName(String sensorName) {
return CollectionUtils.emptyIfNull(sensorDatas)
.stream()
.filter(s -> sensorName.equals(s.getSensorName()))
.map(SensorData::getLocation)
.findFirst()
.orElse(DummyData.UNKNOW_LOCATION);
}
@Override
public void save(SensorData data){
return;
}
}
| 2,583 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
SensorDataPredicate.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/test/java/com/gepardec/hogarama/dao/SensorDataPredicate.java | package com.gepardec.hogarama.dao;
import java.util.Date;
import java.util.function.Predicate;
import jakarta.validation.constraints.NotNull;
import com.gepardec.hogarama.domain.sensor.SensorData;
public class SensorDataPredicate implements Predicate<SensorData> {
private String sensorName;
private Date from;
private Date to;
public SensorDataPredicate(@NotNull String sensorName, Date from, Date to) {
super();
this.sensorName = sensorName;
this.from = from;
this.to = to == null ? new Date() : to;
}
@Override
public boolean test(SensorData t) {
if(t == null || !t.getSensorName().equals(this.sensorName)) {
return false;
}
if (from != null) {
long sensorTimeInLong = t.getTime().getTime();
return sensorTimeInLong >= from.getTime() && sensorTimeInLong <= to.getTime();
}
return true;
}
}
| 879 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
LastNRecordCollector.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/test/java/com/gepardec/hogarama/dao/LastNRecordCollector.java | package com.gepardec.hogarama.dao;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Deque;
import java.util.List;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collector;
public class LastNRecordCollector <T> implements Collector<T, Deque<T>, List<T>> {
private int lastNRecord = 0;
public LastNRecordCollector(int lastNRecord) {
this.lastNRecord = lastNRecord;
}
@Override
public Supplier<Deque<T>> supplier() {
return ArrayDeque::new;
}
@Override
public BiConsumer<Deque<T>, T> accumulator() {
return (list, t) -> {
if (list.size() == lastNRecord) {
list.removeFirst();
}
list.add(t);
};
}
@Override
public BinaryOperator<Deque<T>> combiner() {
return (sourceList, targetList) -> {
while (targetList.size() < lastNRecord && !sourceList.isEmpty()) {
targetList.addFirst(sourceList.removeLast());
}
return targetList;
};
}
@Override
public Function<Deque<T>, List<T>> finisher() {
return ArrayList::new;
}
@Override
public Set<Characteristics> characteristics() {
return Collections.emptySet();
}
}
| 1,332 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
TestCaseLastNRecordCollector.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/test/java/com/gepardec/hogarama/dao/TestCaseLastNRecordCollector.java | package com.gepardec.hogarama.dao;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.ArrayList;
import java.util.List;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
public class TestCaseLastNRecordCollector {
private static final int MAX_NUM = 10;
private LastNRecordCollector<String> collector = new LastNRecordCollector<>((MAX_NUM / 2));
private List<String> list;
@BeforeEach
public void setUp() {
list = new ArrayList<>();
for (int i = 0; i < MAX_NUM; i++) {
list.add("val_" + i);
}
}
@Test
public void testLastNRecord() {
List<String> collectList = list.stream().collect(collector);
assertEquals((MAX_NUM / 2), collectList.size());
assertTrue(collectList.get(collectList.size() - 1).equals(list.get(list.size() - 1)));
assertTrue(collectList.get(0).equals(list.get((list.size() / 2))));
}
}
| 977 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
TestSensors.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/test/java/com/gepardec/hogarama/testdata/TestSensors.java | package com.gepardec.hogarama.testdata;
import java.util.Optional;
import com.gepardec.hogarama.domain.unitmanagement.entity.Sensor;
import com.gepardec.hogarama.domain.unitmanagement.entity.SensorType;
import com.gepardec.hogarama.domain.unitmanagement.entity.Unit;
public class TestSensors {
public static final String DEVICE_GRUENER_GEPARD = "GruenerGepard";
private static final String SPARKFUN = "sparkfun";
private static final long SPARKFUN_ID = 6L;
public static Optional<Sensor> sensorGruenerGepard() {
Sensor sensor = new Sensor();
sensor.setId(99L);
sensor.setDeviceId(DEVICE_GRUENER_GEPARD);
sensor.setName("Grüner Gepard");
sensor.setSensorType( new SensorType(SPARKFUN_ID, SPARKFUN));
sensor.setUnit(unit());
return Optional.ofNullable(sensor);
}
private static Unit unit() {
Unit unit = new Unit();
unit.setId(1L);
unit.setDescription("Unit Description");
unit.setName("My Unit");
return unit;
}
public TestSensors() {
super();
}
} | 1,095 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
DummyDataTest.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/test/java/com/gepardec/hogarama/testdata/DummyDataTest.java | package com.gepardec.hogarama.testdata;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.List;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import com.gepardec.hogarama.domain.sensor.SensorData;
public class DummyDataTest {
private Calendar calendar;
private List<SensorData> sensors;
@BeforeEach
public void setUp() {
calendar = new GregorianCalendar();
sensors = DummyData.getDummySensorData(2, 2, true);
}
@Test
public void testGenerateData() {
assertEquals(4, sensors.size());
SensorData sensorData1 = sensors.get(0);
SensorData sensorData2 = sensors.get(1);
assertTrue(sensorData1.getSensorName().equals(sensorData2.getSensorName()));
assertTrue(sensorData1.getLocation().equals(sensorData2.getLocation()));
assertTrue(sensorData1.getVersion().equals(sensorData2.getVersion()));
assertTrue(sensorData1.getValue() > DummyData.MIN_VAL);
assertTrue(sensorData1.getValue() < DummyData.MAX_VAL);
}
@Test
public void testGenerateSameData() {
List<SensorData> sensor2 = DummyData.getDummySensorData(99, 99, false);
assertTrue(sensors.size() == 4);
assertTrue(sensors.size() == sensor2.size());
assertTrue(sensors.get(0).equals(sensor2.get(0)));
}
@Test
public void testSetYear() {
DummyData.setYear(calendar);
assertEquals(2018, calendar.get(Calendar.YEAR));
}
@Test
public void testSetMonth() {
DummyData.setMonth(calendar);
int month = calendar.get(Calendar.MONTH);
assertTrue(month >= 0);
assertTrue(month <= 11);
}
@Test
public void testSetDay() {
DummyData.setDay(calendar);
int month = calendar.get(Calendar.DAY_OF_MONTH);
assertTrue(month >= 1);
assertTrue(month <= calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
}
@Test
public void testSetHour() {
DummyData.setHour(calendar);
int month = calendar.get(Calendar.HOUR);
assertTrue(month >= 0);
assertTrue(month <= 23);
}
@Test
public void testSetMinute() {
DummyData.setMinute(calendar);
int month = calendar.get(Calendar.MINUTE);
assertTrue(month >= 0);
assertTrue(month <= 59);
}
}
| 2,316 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
DummyData.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/test/java/com/gepardec/hogarama/testdata/DummyData.java | package com.gepardec.hogarama.testdata;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.List;
import java.util.Random;
import java.util.UUID;
import com.gepardec.hogarama.domain.sensor.SensorData;
public class DummyData {
public static final String UNKNOW_LOCATION = "unknown location";
public static final int MIN_VAL = 0;
public static final int MAX_VAL = 100;
public static final String SENSOR_TYPE = "wasser";
public static final String SENSOR_NAME = "dummySensor";
public static final String SENSOR_VERSION = "1";
public static final String SENSOR_LOCATION = "dummyLocation";
private static final List<SensorData> sensorDatas = new ArrayList<>();
private static final Random RANDOM = new Random();
private DummyData() {
//static
}
public static List<SensorData> getDummySensorData(int numberOfSensor, int numberOfData, boolean newData) {
if (sensorDatas.isEmpty() || newData) {
sensorDatas.clear();
generateDummySensorData(numberOfSensor, numberOfData);
}
return new ArrayList<>(sensorDatas);
}
private static void generateDummySensorData(int numberOfSensor, int numberOfData) {
for (int i = 0; i < numberOfSensor; i++) {
String sensorName = SENSOR_NAME + i;
String type = SENSOR_TYPE;
String version = SENSOR_VERSION;
String location = SENSOR_LOCATION + i;
for (int j = 0; j < numberOfData; j++) {
String id = UUID.randomUUID().toString();
Date time = getRandomTime();
double value = getRandomIntBetween(MIN_VAL, MAX_VAL);
sensorDatas.add(new SensorData(id, time, sensorName, type, value, location, version));
}
}
}
public static Date getRandomTime() {
Calendar gc = new GregorianCalendar();
setRandomDate(gc);
return gc.getTime();
}
private static void setRandomDate(Calendar gc) {
setYear(gc);
setMonth(gc);
setDay(gc);
setHour(gc);
setMinute(gc);
}
public static void setYear(Calendar gc) {
int year = 2018;
gc.set(GregorianCalendar.YEAR, year);
}
public static void setMonth(Calendar gc) {
int monthOfYear = getRandomIntBetween(0, 11);
gc.set(GregorianCalendar.MONTH, monthOfYear);
}
public static void setDay(Calendar gc) {
int dayOfMonth = getRandomIntBetween(1, gc.getActualMaximum(Calendar.DAY_OF_MONTH));
gc.set(Calendar.DAY_OF_MONTH, dayOfMonth);
}
public static void setHour(Calendar gc) {
int hourOfDay = getRandomIntBetween(0, 23);
gc.set(Calendar.HOUR_OF_DAY, hourOfDay);
}
public static void setMinute(Calendar gc) {
int minuteOfHour = getRandomIntBetween(0, 59);
gc.set(Calendar.MINUTE, minuteOfHour);
}
public static int getRandomIntBetween(int start, int end) {
return start + RANDOM.nextInt(end-start);
}
}
| 2,847 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
TestDataProducer.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/test/java/com/gepardec/hogarama/testdata/TestDataProducer.java | package com.gepardec.hogarama.testdata;
import com.gepardec.hogarama.domain.sensor.SensorData;
import com.gepardec.hogarama.domain.watering.WateringService;
import java.time.Duration;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
import static com.gepardec.hogarama.domain.DateUtils.toDate;
import static com.gepardec.hogarama.domain.DateUtils.toLocalDateTime;
public class TestDataProducer {
private ArrayList<SensorData> data;
private SensorData akt;
private LocalDateTime lastTime;
private int index = -1;
public TestDataProducer(SensorData sensorData) {
data = new ArrayList<SensorData>();
akt = sensorData;
data.add(akt);
lastTime = toLocalDateTime(akt.getTime());
}
public void addValueMinusMinutes(double value, int minutes) {
addValueAt( value, lastTime.minus(Duration.ofMinutes(minutes)));
}
public void addValueAt(double value, LocalDateTime time) {
akt = copy(akt);
akt.setId(Integer.toString(Integer.parseInt(akt.getId()) + 1 ));
lastTime = time;
akt.setTime(toDate(lastTime));
akt.setValue(value);
data.add(akt);
}
private SensorData copy(SensorData from) {
SensorData to = new SensorData();
to.setId(from.getId());
to.setLocation(from.getLocation());
to.setSensorName(from.getSensorName());
to.setTime(from.getTime());
to.setType(from.getType());
to.setValue(from.getValue());
to.setVersion(from.getVersion());
return to;
}
public List<SensorData> getData() {
return data;
}
public SensorData getNext() {
return data.get(++index);
}
public void waterAll(WateringService watering) {
for (SensorData sensorData : data) {
watering.processSensorData(sensorData);
}
}
}
| 1,734 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
DaoTest.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/test/java/com/gepardec/hogarama/domain/watering/DaoTest.java | package com.gepardec.hogarama.domain.watering;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
public class DaoTest {
private InMemoryWateringConfigDAO dao = new InMemoryWateringConfigDAO();
@BeforeEach
public void setUp() throws Exception {
dao.setUpForTest();
}
@Test
public void test() {
WateringConfigData wconf = new WateringConfigData("sensor", "actor", 0.2, 5);
dao.save(wconf);
String id = "sensor";
WateringRule c1 = dao.getBySensorName(id);
assertEquals("sensor", c1.getSensorName());
assertEquals("actor", c1.getActorName());
assertNull(dao.getBySensorName("sensor1"));
}
}
| 771 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
WateringServiceTest.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/test/java/com/gepardec/hogarama/domain/watering/WateringServiceTest.java | package com.gepardec.hogarama.domain.watering;
import com.gepardec.hogarama.dao.DummySensorDAO;
import com.gepardec.hogarama.domain.sensor.SensorData;
import com.gepardec.hogarama.domain.sensor.SensorDataDAO;
import com.gepardec.hogarama.domain.sensor.SensorNormalizer;
import com.gepardec.hogarama.domain.unitmanagement.cache.ActorCache;
import com.gepardec.hogarama.domain.unitmanagement.cache.SensorCache;
import com.gepardec.hogarama.domain.unitmanagement.entity.Actor;
import com.gepardec.hogarama.domain.unitmanagement.entity.Sensor;
import com.gepardec.hogarama.domain.unitmanagement.entity.Unit;
import com.gepardec.hogarama.testdata.TestDataProducer;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
import org.mockito.stubbing.Answer;
import java.time.LocalDateTime;
import java.time.Month;
import java.util.Optional;
import static com.gepardec.hogarama.domain.DateUtils.toDate;
import static org.junit.jupiter.api.Assertions.*;
public class WateringServiceTest {
private static final String SENSOR_DEVICE_ID = "SensorDeviceId";
private static final String SENSOR_NAME = "SensorName";
private static final String UNIT_NAME = "SensorUnit";
private static final String ACTOR_DEVICE_ID = "ActorDeviceId";
private static final String ACTOR_NAME = "ActorName";
private ActorCache actorCache;
private SensorCache sensorCache;
private SensorNormalizer sensorNormalizer;
private WateringService watering;
private MockActorControlService actorSvc;
private InMemoryWateringConfigDAO wateringConfigDao;
private TestDataProducer data;
@BeforeEach
public void setUp() {
actorCache = Mockito.mock(ActorCache.class);
sensorCache = Mockito.mock(SensorCache.class);
SensorDataDAO sensorDataDAO = Mockito.mock(SensorDataDAO.class);
sensorNormalizer = Mockito.mock(SensorNormalizer.class);
Mockito.when(actorCache.getByDeviceId(Mockito.any())).thenReturn(Optional.of(newActor()));
Mockito.when(sensorCache.getByDeviceId(Mockito.any())).thenReturn(Optional.of(newSensor()));
Mockito.when(sensorNormalizer.normalize(Mockito.any(SensorData.class))).thenAnswer(((Answer<SensorData>) invocationOnMock -> (SensorData) invocationOnMock.getArguments()[0]));
}
private Sensor newSensor() {
Sensor sensor = new Sensor();
sensor.setDeviceId(SENSOR_DEVICE_ID);
sensor.setName(SENSOR_NAME);
Unit unit = new Unit();
unit.setName(UNIT_NAME);
sensor.setUnit(unit);
return sensor;
}
private Actor newActor() {
Actor actor = new Actor();
actor.setDeviceId(ACTOR_DEVICE_ID);
actor.setName(ACTOR_NAME);
return actor;
}
private void setupWatering(MockActorControlService actorSvc, InMemoryWateringConfigDAO wateringConfigDao) {
data = new TestDataProducer(startSensorData());
data.addValueMinusMinutes(0.1, 10);
data.addValueMinusMinutes(0.1, 10);
data.addValueAt(0.6, LocalDateTime.of(2019, Month.JUNE, 20, 14, 00));
DummySensorDAO sensorDao = new DummySensorDAO(data.getData());
watering = new WateringService(sensorDao, sensorNormalizer, actorSvc, new WateringStrategy(), wateringConfigDao, actorCache, sensorCache);
}
private void setupWatering() {
actorSvc = new MockActorControlService("Vienna", "My Plant", WateringService.Config.DEFAULT.waterDuration);
wateringConfigDao = new InMemoryWateringConfigDAO();
setupWatering(actorSvc, wateringConfigDao);
}
@Test
public void testWateringOfMyPlant() {
setupWatering();
waterAll();
assertTrue(actorSvc.wasCalled(), "Actor was called");
}
@Test
public void testChangeDefaultConfiguration() {
InMemoryWateringConfigDAO wateringConfigDao = new InMemoryWateringConfigDAO();
WateringConfigData wconfig = new WateringConfigData("My Plant", "My Plant", 0.2, 6);
wateringConfigDao.save(wconfig);
MockActorControlService actor = new MockActorControlService("Vienna", "My Plant", 6);
setupWatering(actor, wateringConfigDao);
waterAll();
assertTrue(actor.wasCalled(), "Actor was called");
}
@Test
public void testUseDifferentActorNameThanSensorName() {
InMemoryWateringConfigDAO wateringConfigDao = new InMemoryWateringConfigDAO();
WateringConfigData wconfig = new WateringConfigData("My Plant", "My Actor", 0.2, 6);
wateringConfigDao.save(wconfig);
MockActorControlService actor = new MockActorControlService("Vienna", "My Actor", 6);
setupWatering(actor, wateringConfigDao);
waterAll();
assertTrue(actor.wasCalled(), "Actor was called");
}
@Test
public void testWateringWillSaveDefaultConfig() {
setupWatering();
waterAll();
assertNotNull(wateringConfigDao.getBySensorName("My Plant"));
}
@Test
public void testLowValueWillTriggerWatering() {
setupWatering();
SensorData val = data.getNext();
assertEquals(0.1, val.getValue(), 0.01);
watering.processSensorData(val);
assertTrue(actorSvc.wasCalled(), "Actor was called");
}
@Test
public void testHighValueWontTriggerWatering() {
setupWatering();
data.getNext();
data.getNext();
data.getNext();
SensorData val = data.getNext();
assertEquals(0.6, val.getValue(), 0.01);
watering.processSensorData(val);
assertFalse(actorSvc.wasCalled(), "Actor was not called");
}
@Test
public void testStrategieUsesAverage() {
setupWatering();
watering.processSensorData(data.getNext().setValue(0.4));
assertFalse(actorSvc.wasCalled(), "Actor was not called with 0.4");
watering.processSensorData(data.getNext().setValue(0.1));
assertFalse(actorSvc.wasCalled(), "Actor was not called with 0.1");
watering.processSensorData(data.getNext().setValue(0.1));
assertFalse(actorSvc.wasCalled(), "Actor was not called with second 0.1");
watering.processSensorData(data.getNext().setValue(0.1));
assertTrue(actorSvc.wasCalled(), "Actor was called with third 0.1");
}
private SensorData startSensorData() {
return new SensorData(
"1",
toDate(LocalDateTime.of(2018, Month.JUNE, 20, 15, 00)),
"My Plant",
"noramlised",
0.1,
"Vienna",
"1.0");
}
private void waterAll() {
data.waterAll(watering);
}
private static class MockActorControlService implements ActorControlService {
private final String location;
private final String actorName;
private final Integer duration;
private boolean wasCalled = false;
public MockActorControlService(String location, String actorName, Integer duration) {
this.location = location;
this.actorName = actorName;
this.duration = duration;
}
public boolean wasCalled() {
return wasCalled;
}
@Override
public void sendActorMessage(String location, String actorName, Integer duration) {
assertEquals(this.location, location);
assertEquals(this.actorName, actorName);
assertEquals(this.duration, duration);
wasCalled = true;
}
}
}
| 7,544 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
InMemoryWateringConfigDAO.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/test/java/com/gepardec/hogarama/domain/watering/InMemoryWateringConfigDAO.java | package com.gepardec.hogarama.domain.watering;
import java.util.HashMap;
public class InMemoryWateringConfigDAO implements WateringRuleDAO {
private HashMap<String, WateringRule> store = new HashMap<>();
@Override
public void save(WateringRule wconf) {
store.put(wconf.getSensorName(), wconf);
}
@Override
public WateringRule getBySensorName(String id) {
return store.get(id);
}
public void setUpForTest() {
// TODO Auto-generated method stub
}
@Override
public WateringRule createWateringRule(String sensorName, String actorName, double lowWater, int waterDuration) {
return new WateringConfigData(sensorName, actorName, lowWater, waterDuration);
}
}
| 700 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
SensorPropertiesTest.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/test/java/com/gepardec/hogarama/domain/sensor/SensorPropertiesTest.java | package com.gepardec.hogarama.domain.sensor;
import static com.gepardec.hogarama.testdata.TestSensors.DEVICE_GRUENER_GEPARD;
import static com.gepardec.hogarama.testdata.TestSensors.sensorGruenerGepard;
import static org.assertj.core.api.Assertions.assertThat;
import java.util.Optional;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.jupiter.MockitoExtension;
import com.gepardec.hogarama.domain.unitmanagement.cache.SensorCache;
import com.gepardec.hogarama.testdata.TestSensors;
@ExtendWith(MockitoExtension.class)
public class SensorPropertiesTest {
private static final String DEVICE_ID_NOTFOUND = "SomeSensor";
@Mock
private SensorCache sensorCache;
@BeforeEach
public void setUpMethod() throws Exception {
Mockito.lenient().when(sensorCache.getByDeviceId(DEVICE_ID_NOTFOUND)).thenReturn(Optional.empty());
Mockito.lenient().when(sensorCache.getByDeviceId(DEVICE_GRUENER_GEPARD)).thenReturn(TestSensors.sensorGruenerGepard());
}
@Test
public void dbSensorReturnsDeviceIdAsDeviceId() {
assertThat(gruenerGepardProperties().getDeviceId())
.isEqualTo(sensorGruenerGepard().get().getDeviceId());
}
@Test
public void unknownSensorReturnsSensorNameAsDeviceId() {
assertThat(unknownSensorProperties().getDeviceId())
.isEqualTo(unknownSensorData().getSensorName());
}
@Test
public void dbSensorReturnsNameAsSensorName() {
assertThat(gruenerGepardProperties().getSensorName())
.isEqualTo(sensorGruenerGepard().get().getName());
}
@Test
public void unknownSensorReturnsSensorNameAsSensorName() {
assertThat(unknownSensorProperties().getSensorName())
.isEqualTo(unknownSensorData().getSensorName());
}
@Test
public void dbSensorReturnsUnitNameAsUnitName() {
assertThat(gruenerGepardProperties().getUnitName())
.isEqualTo(sensorGruenerGepard().get().getUnit().getName());
}
@Test
public void unknownSensorReturnsLocationAsUnitName() {
assertThat(unknownSensorProperties().getUnitName())
.isEqualTo(unknownSensorData().getLocation());
}
@Test
public void dbSensorReturnsLINEAR1024AsMappingType() {
assertThat(gruenerGepardProperties().getMappingType())
.isEqualTo(MappingType.LINEAR1024);
}
@Test
public void unknownSensorReturnsINVERSE_LINEAR1024AsMappingType() {
assertThat(unknownSensorProperties().getMappingType())
.isEqualTo(MappingType.INVERSE_LINEAR1024);
}
private SensorProperties gruenerGepardProperties() {
return new SensorProperties(gruenerGepardData(), sensorCache);
}
private SensorProperties unknownSensorProperties() {
return new SensorProperties(unknownSensorData(), sensorCache);
}
private SensorData unknownSensorData() {
SensorData data = new SensorData();
data.setSensorName(DEVICE_ID_NOTFOUND);
data.setLocation("Linz");
data.setType("Chinese Water Sensor");
data.setVersion("1");
data.setValue(0.45);
return data;
}
private SensorData gruenerGepardData() {
SensorData data = new SensorData();
data.setSensorName(DEVICE_GRUENER_GEPARD);
data.setLocation("Wien");
data.setType("sparkfun");
data.setVersion("1");
data.setValue(0.566);
return data;
}
}
| 3,582 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
SensorNormalizerTest.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/test/java/com/gepardec/hogarama/domain/sensor/SensorNormalizerTest.java | package com.gepardec.hogarama.domain.sensor;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.mock;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import java.util.Optional;
import com.gepardec.hogarama.domain.unitmanagement.cache.SensorCache;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;
import org.mockito.Mockito;
public class SensorNormalizerTest {
private static final String LINEAR1024 = "LINEAR1024";
private static final double PRECISION = 0.01;
private SensorNormalizer sn;
private Double expectedValue;
private String type;
private Double value;
private static final String DEVICE_ID = "My Plant";
SensorCache sensorCache;
public static Collection<Object[]> data() {
Object[][] data = new Object[][] {
{ 0.56, "UnknownSensorType", 56.0 },
{ 0.0, LINEAR1024, 0.0 },
{ 1.0, LINEAR1024, 1024.0 },
{ 0.5, LINEAR1024, 512.0 },
{ 0.0, "INVERSE_LINEAR1024", 1024.0 },
{ 1.0, "INVERSE_LINEAR1024", 0.0 }
};
return Arrays.asList(data);
}
public void initSensorNormalizerTest(Double expectedValue, String type, Double value) {
this.expectedValue = expectedValue;
this.type = type;
this.value = value;
}
@BeforeEach
public void setUpMethod() throws Exception {
sn = new SensorNormalizer();
sensorCache = mock(SensorCache.class);
Mockito.when(sensorCache.getByDeviceId(DEVICE_ID)).thenReturn(Optional.empty());
sn.setSensorCache(sensorCache);
}
@MethodSource("data")
@ParameterizedTest
public void testNormalize(Double expectedValue, String type, Double value) throws Exception {
initSensorNormalizerTest(expectedValue, type, value);
assertEquals(expectedValue, normalized(type, value), PRECISION);
}
private double normalized(String type, Double value) {
return sn.normalize(createSensorData(type, value)).getValue();
}
static public SensorData createSensorData(String type, Double value) {
return new SensorData("1", new Date(), "My Plant", type, value, "Vienna", "1.0");
}
static public void checkNormalised(List<SensorData> sensorData) {
int index = 0;
for (Object[] objects : data()) {
assertEquals(objects[0], sensorData.get(index).getValue(), "Index " + index);
index++;
}
}
static public List<SensorData> getDataList() {
List<SensorData> sensorData = new ArrayList<SensorData>();
for (Object[] objects : data()) {
sensorData.add(SensorNormalizerTest.createSensorData((String)objects[1], (double)objects[2]));
}
return sensorData;
}
}
| 2,712 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
SensorDataListNormalizerTest.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/test/java/com/gepardec/hogarama/domain/sensor/SensorDataListNormalizerTest.java | package com.gepardec.hogarama.domain.sensor;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.jupiter.MockitoExtension;
import com.gepardec.hogarama.domain.unitmanagement.cache.SensorCache;
import static org.junit.jupiter.api.Assertions.assertTrue;
@ExtendWith(MockitoExtension.class)
public class SensorDataListNormalizerTest {
private static final String DEVICE_ID = "My Plant";
@Mock
private SensorCache sensorCache;
@InjectMocks
private SensorNormalizer sn;
@Test
public void emptyListReturnsEmptyList() {
List<SensorData> data = sn.normalize(Collections.emptyList());
assertTrue(data.isEmpty());
}
@Test
public void testFullList() throws Exception {
Mockito.when(sensorCache.getByDeviceId(DEVICE_ID)).thenReturn(Optional.empty());
SensorNormalizerTest.checkNormalised(
sn.normalize(SensorNormalizerTest.getDataList()));
}
}
| 1,157 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
TestCaseSensorDataPredicate.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/test/java/com/gepardec/hogarama/domain/sensor/TestCaseSensorDataPredicate.java | package com.gepardec.hogarama.domain.sensor;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.List;
import java.util.stream.Collectors;
import com.gepardec.hogarama.dao.SensorDataPredicate;
import com.gepardec.hogarama.testdata.DummyData;
import org.junit.jupiter.api.Test;
public class TestCaseSensorDataPredicate {
private List<SensorData> list = DummyData.getDummySensorData(2, 100, true);
@Test
public void testSensorDataPredicateBadName() {
List<SensorData> result = list.stream()
.filter(new SensorDataPredicate("NOTIN123", null, null))
.collect(Collectors.toList());
assertEquals(0, result.size());
}
@Test
public void testSensorDataPredicateNullName() {
List<SensorData> result = list.stream()
.filter(new SensorDataPredicate(null, null, null))
.collect(Collectors.toList());
assertEquals(0, result.size());
}
@Test
public void testSensorDataPredicateWithName() {
List<SensorData> result = list.stream()
.filter(new SensorDataPredicate(DummyData.SENSOR_NAME + "0", null, null))
.collect(Collectors.toList());
assertTrue(result.size() > 0);
}
@Test
public void testSensorDataPredicateWithNameAndFrom1() {
Calendar calendar = new GregorianCalendar(1990, 01, 01);
List<SensorData> result = list.stream()
.filter(new SensorDataPredicate(DummyData.SENSOR_NAME + "0", calendar.getTime(), null))
.collect(Collectors.toList());
assertTrue(result.size() > 0);
}
@Test
public void testSensorDataPredicateWithNameAndFrom2() {
Calendar calendar = new GregorianCalendar(2999, 01, 01);
List<SensorData> result = list.stream()
.filter(new SensorDataPredicate(DummyData.SENSOR_NAME + "0", calendar.getTime(), null))
.collect(Collectors.toList());
assertEquals(0, result.size());
}
}
| 2,076 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
SensorCacheTest.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/test/java/com/gepardec/hogarama/domain/sensor/SensorCacheTest.java | package com.gepardec.hogarama.domain.sensor;
import static com.gepardec.hogarama.testdata.TestSensors.DEVICE_GRUENER_GEPARD;
import static org.assertj.core.api.Assertions.assertThat;
import java.util.Optional;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.jupiter.MockitoExtension;
import com.gepardec.hogarama.domain.unitmanagement.cache.SensorCache;
import com.gepardec.hogarama.domain.unitmanagement.dao.SensorDAO;
import com.gepardec.hogarama.domain.unitmanagement.entity.Sensor;
import com.gepardec.hogarama.testdata.TestSensors;
@ExtendWith(MockitoExtension.class)
public class SensorCacheTest{
private static final String LINEAR1024 = "LINEAR1024";
@Mock
private SensorDAO sensorDAO;
@InjectMocks
private SensorCache sensorCache;
@BeforeEach
public void setUpMethod() {
Mockito.when(sensorDAO.getByDeviceId(DEVICE_GRUENER_GEPARD)).thenReturn(TestSensors.sensorGruenerGepard());
}
@Test
public void sensorCacheReturnsGruenerGepard() throws Exception {
Optional<Sensor> sensor = sensorCache.getByDeviceId(DEVICE_GRUENER_GEPARD);
assertThat(sensor.isPresent());
assertThat(sensor.get().getName()).isEqualTo("Grüner Gepard");
Mockito.verify(sensorDAO).getByDeviceId(DEVICE_GRUENER_GEPARD);
}
@Test
public void sensorCacheCaches() throws Exception {
Optional<Sensor> sensor = sensorCache.getByDeviceId(DEVICE_GRUENER_GEPARD);
assertThat(sensor.isPresent());
assertThat(sensor.get().getName()).isEqualTo("Grüner Gepard");
sensor = sensorCache.getByDeviceId(DEVICE_GRUENER_GEPARD);
assertThat(sensor.isPresent());
assertThat(sensor.get().getName()).isEqualTo("Grüner Gepard");
Mockito.verify(sensorDAO).getByDeviceId(DEVICE_GRUENER_GEPARD);
Mockito.verifyNoMoreInteractions(sensorDAO);
}
@Test
public void invalidateRemovesCachedValue() throws Exception {
Optional<Sensor> sensor = sensorCache.getByDeviceId(DEVICE_GRUENER_GEPARD);
assertThat(sensor.isPresent());
assertThat(sensor.get().getName()).isEqualTo("Grüner Gepard");
sensorCache.invalidateCache(sensor.get());
sensor = sensorCache.getByDeviceId(DEVICE_GRUENER_GEPARD);
assertThat(sensor.isPresent());
assertThat(sensor.get().getName()).isEqualTo("Grüner Gepard");
Mockito.verify(sensorDAO, Mockito.times(2)).getByDeviceId(DEVICE_GRUENER_GEPARD);
}
@Test
public void GruenerGepardHasMappingTypeLINEAR1024() throws Exception {
Optional<Sensor> sensor = sensorCache.getByDeviceId(DEVICE_GRUENER_GEPARD);
assertThat(sensor.get().getSensorType().getMappingType().name()).isEqualTo(LINEAR1024);
}
}
| 2,945 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
UserTest.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/test/java/com/gepardec/hogarama/domain/unitmanagement/entity/UserTest.java | package com.gepardec.hogarama.domain.unitmanagement.entity;
import com.gepardec.hogarama.domain.exception.TechnicalException;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows;
public class UserTest {
@Test
public void addUnit() {
User user = new User();
Unit unit = new Unit();
user.addUnit(unit);
assertThat(user.getUnitList()).containsExactly(unit);
}
@Test
public void addUnit_NullInput_ExceptionExpected() {
assertThrows(NullPointerException.class, () -> {
User user = new User();
user.addUnit(null);
});
}
@Test
public void getDefaultUnit_EmptyUnitList() {
assertThrows(NullPointerException.class, () -> {
User user = new User();
user.getDefaultUnit();
});
}
@Test
public void getDefaultUnit_NoDefaultUnitPresent() {
assertThrows(TechnicalException.class, () -> {
User user = new User();
user.addUnit(newNonDefaultUnit());
user.getDefaultUnit();
});
}
@Test
public void getDefaultUnit() {
User user = new User();
// add default unit
Unit defaultUnit = Unit.createDefault(user);
user.addUnit(defaultUnit);
// add non default unit
user.addUnit(newNonDefaultUnit());
Unit result = user.getDefaultUnit();
assertThat(result).isEqualTo(defaultUnit);
}
private Unit newNonDefaultUnit() {
Unit unit = new Unit();
unit.setDefaultUnit(false);
return unit;
}
}
| 1,694 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
UserProfileServiceTest.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/test/java/com/gepardec/hogarama/domain/unitmanagement/service/UserProfileServiceTest.java | package com.gepardec.hogarama.domain.unitmanagement.service;
import com.gepardec.hogarama.domain.unitmanagement.context.UserContext;
import com.gepardec.hogarama.domain.unitmanagement.entity.UserProfile;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.jupiter.MockitoExtension;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows;
@ExtendWith(MockitoExtension.class)
public class UserProfileServiceTest {
@Mock
private UserContext userContext;
@InjectMocks
private UserProfileService service;
@Test
public void userProfileNotSet_exceptionIsThrown() throws Exception {
assertThrows(RuntimeException.class, () -> {
service.getUserProfile();
});
}
@Test
public void userProfileSet_correctResult() throws Exception {
UserProfile mockProfile = new UserProfile();
Mockito.when(userContext.getUserProfile()).thenReturn(mockProfile);
UserProfile userProfile = service.getUserProfile();
assertThat(userProfile).isNotNull().isEqualTo(mockProfile);
}
}
| 1,268 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
RuleServiceTest.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/test/java/com/gepardec/hogarama/domain/unitmanagement/service/RuleServiceTest.java | package com.gepardec.hogarama.domain.unitmanagement.service;
import static org.junit.jupiter.api.Assertions.assertThrows;
import com.gepardec.hogarama.domain.exception.TechnicalException;
import com.gepardec.hogarama.domain.unitmanagement.context.UserContext;
import com.gepardec.hogarama.domain.unitmanagement.dao.RuleDAO;
import com.gepardec.hogarama.domain.unitmanagement.entity.LowWaterWateringRule;
import com.gepardec.hogarama.domain.unitmanagement.entity.User;
import com.gepardec.hogarama.domain.unitmanagement.entity.Unit;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.jupiter.MockitoExtension;
import jakarta.enterprise.event.Event;
import java.util.Collections;
import java.util.Optional;
@ExtendWith(MockitoExtension.class)
public class RuleServiceTest {
private static final Long RULE_ID = 3537L;
@Mock
private RuleDAO dao;
@Mock
private UserContext userContext;
@InjectMocks
private RuleService service;
@Mock
Event<LowWaterWateringRule> ruleChanged;
private Unit unit;
private User user;
@BeforeEach
public void setUp() {
user = newUser();
Mockito.lenient().when(userContext.getUser()).thenReturn(user);
}
@Test
public void createRule_OK() {
LowWaterWateringRule rule = newRule();
service.createRule(rule);
Mockito.verify(dao).save(rule);
Mockito.verifyNoMoreInteractions(dao);
}
@Test
public void createRule_UnitDoesntBelongToUser() {
assertThrows(TechnicalException.class, () -> {
LowWaterWateringRule rule = newRuleWithNotBelongingUnit();
service.createRule(rule);
});
}
@Test
public void deleteRule() {
LowWaterWateringRule rule = newRule();
Mockito.when(dao.getById(RULE_ID)).thenReturn(Optional.of(rule));
service.deleteRule(RULE_ID);
Mockito.verify(dao).delete(rule);
}
@Test
public void updateRule_OK() {
LowWaterWateringRule rule = newRule();
service.updateRule(rule);
Mockito.verify(dao).update(rule);
Mockito.verifyNoMoreInteractions(dao);
}
@Test
public void updateRule_UnitDoesntBelongToUser() {
assertThrows(TechnicalException.class, () -> {
LowWaterWateringRule rule = newRuleWithNotBelongingUnit();
service.updateRule(rule);
});
}
@Test
public void getAllRulesForUser() {
service.getAllRulesForUser();
Mockito.verify(dao).getAllRulesForUser(user);
}
private User newUser() {
User user = new User();
user.setId(-1L);
this.unit = new Unit();
unit.setId(1337L);
unit.setUser(user);
user.setUnitList(Collections.singletonList(unit));
return user;
}
private LowWaterWateringRule newRule() {
LowWaterWateringRule rule = new LowWaterWateringRule();
rule.setId(RULE_ID);
rule.setUnit(unit);
return rule;
}
private LowWaterWateringRule newRuleWithNotBelongingUnit() {
LowWaterWateringRule rule = new LowWaterWateringRule();
Unit unit = new Unit();
unit.setId(-1L);
rule.setUnit(unit);
return rule;
}
}
| 3,429 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
SensorServiceTest.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/test/java/com/gepardec/hogarama/domain/unitmanagement/service/SensorServiceTest.java | package com.gepardec.hogarama.domain.unitmanagement.service;
import static org.junit.jupiter.api.Assertions.assertThrows;
import com.gepardec.hogarama.domain.exception.TechnicalException;
import com.gepardec.hogarama.domain.unitmanagement.context.UserContext;
import com.gepardec.hogarama.domain.unitmanagement.dao.SensorDAO;
import com.gepardec.hogarama.domain.unitmanagement.entity.User;
import com.gepardec.hogarama.domain.unitmanagement.entity.Sensor;
import com.gepardec.hogarama.domain.unitmanagement.entity.Unit;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.jupiter.MockitoExtension;
import java.util.Collections;
import java.util.Optional;
import jakarta.enterprise.event.Event;
@ExtendWith(MockitoExtension.class)
public class SensorServiceTest {
private static final Long SENSOR_ID = 3537L;
@Mock
private SensorDAO dao;
@Mock
private UserContext userContext;
@Mock
Event<Sensor> sensorChanged;
@InjectMocks
private SensorService service;
private Unit unit;
private User user;
@BeforeEach
public void setUp() {
user = newUser();
Mockito.lenient().when(userContext.getUser()).thenReturn(user);
}
@Test
public void createSensor_OK() {
Sensor sensor = newSensor();
service.createSensor(sensor);
Mockito.verify(dao).save(sensor);
Mockito.verifyNoMoreInteractions(dao);
}
@Test
public void createSensor_UnitDoesntBelongToUser() {
assertThrows(TechnicalException.class, () -> {
Sensor sensor = newSensorWithNotBelongingUnit();
service.createSensor(sensor);
});
}
@Test
public void deleteSensor() {
Sensor sensor = newSensor();
Mockito.when(dao.getById(SENSOR_ID)).thenReturn(Optional.of(sensor));
service.deleteSensor(SENSOR_ID);
Mockito.verify(dao).delete(sensor);
Mockito.verify(sensorChanged).fire(sensor);
}
@Test
public void updateSensor_OK() {
Sensor sensor = newSensor();
service.updateSensor(sensor);
Mockito.verify(dao).update(sensor);
Mockito.verifyNoMoreInteractions(dao);
Mockito.verify(sensorChanged).fire(sensor);
}
@Test
public void updateSensor_UnitDoesntBelongToUser() {
assertThrows(TechnicalException.class, () -> {
Sensor sensor = newSensorWithNotBelongingUnit();
service.updateSensor(sensor);
Mockito.verifyNoMoreInteractions(sensorChanged);
});
}
@Test
public void getAllSensorForUser() {
service.getAllSensorsForUser();
Mockito.verify(dao).getAllSensorsForUser(user);
}
private User newUser() {
User user = new User();
user.setId(-1L);
this.unit = new Unit();
unit.setId(1337L);
unit.setUser(user);
user.setUnitList(Collections.singletonList(unit));
return user;
}
private Sensor newSensor() {
Sensor sensor = new Sensor();
sensor.setId(SENSOR_ID);
sensor.setUnit(unit);
return sensor;
}
private Sensor newSensorWithNotBelongingUnit() {
Sensor sensor = new Sensor();
Unit unit = new Unit();
unit.setId(-1L);
sensor.setUnit(unit);
return sensor;
}
}
| 3,514 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
ActorServiceTest.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/test/java/com/gepardec/hogarama/domain/unitmanagement/service/ActorServiceTest.java | package com.gepardec.hogarama.domain.unitmanagement.service;
import static org.junit.jupiter.api.Assertions.assertThrows;
import com.gepardec.hogarama.domain.exception.TechnicalException;
import com.gepardec.hogarama.domain.unitmanagement.context.UserContext;
import com.gepardec.hogarama.domain.unitmanagement.dao.ActorDAO;
import com.gepardec.hogarama.domain.unitmanagement.entity.Actor;
import com.gepardec.hogarama.domain.unitmanagement.entity.User;
import com.gepardec.hogarama.domain.unitmanagement.entity.Unit;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.jupiter.MockitoExtension;
import jakarta.enterprise.event.Event;
import java.util.Collections;
import java.util.Optional;
@ExtendWith(MockitoExtension.class)
public class ActorServiceTest {
private static final Long ACTOR_ID = 3537L;
@Mock
private ActorDAO dao;
@Mock
private UserContext userContext;
@InjectMocks
private ActorService service;
@Mock
Event<Actor> actorChanged;
private Unit unit;
private User user;
@BeforeEach
public void setUp() {
user = newUser();
Mockito.lenient().when(userContext.getUser()).thenReturn(user);
}
@Test
public void createActor_OK() {
Actor actor = newActor();
service.createActor(actor);
Mockito.verify(dao).save(actor);
Mockito.verifyNoMoreInteractions(dao);
}
@Test
public void createActor_UnitDoesntBelongToUser() {
assertThrows(TechnicalException.class, () -> {
Actor actor = newActorWithNotBelongingUnit();
service.createActor(actor);
});
}
@Test
public void deleteActor() {
Actor actor = newActor();
Mockito.when(dao.getById(ACTOR_ID)).thenReturn(Optional.of(actor));
service.deleteActor(ACTOR_ID);
Mockito.verify(dao).delete(actor);
}
@Test
public void updateActor_OK() {
Actor actor = newActor();
service.updateActor(actor);
Mockito.verify(dao).update(actor);
Mockito.verifyNoMoreInteractions(dao);
}
@Test
public void updateActor_UnitDoesntBelongToUser() {
assertThrows(TechnicalException.class, () -> {
Actor actor = newActorWithNotBelongingUnit();
service.updateActor(actor);
});
}
@Test
public void getAllActorsForUser() {
service.getAllActorsForUser();
Mockito.verify(dao).getAllActorsForUser(user);
}
private User newUser() {
User user = new User();
user.setId(-1L);
this.unit = new Unit();
unit.setId(1337L);
unit.setUser(user);
user.setUnitList(Collections.singletonList(unit));
return user;
}
private Actor newActor() {
Actor actor = new Actor();
actor.setId(ACTOR_ID);
actor.setUnit(unit);
return actor;
}
private Actor newActorWithNotBelongingUnit() {
Actor actor = new Actor();
Unit unit = new Unit();
unit.setId(-1L);
actor.setUnit(unit);
return actor;
}
}
| 3,283 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
UserProfileResolver.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/main/java/com/gepardec/hogarama/security/UserProfileResolver.java | package com.gepardec.hogarama.security;
import com.gepardec.hogarama.domain.unitmanagement.entity.UserProfile;
import jakarta.ws.rs.core.SecurityContext;
public interface UserProfileResolver {
UserProfile resolveUserProfile();
}
| 234 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
FlywayIntegrator.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/main/java/com/gepardec/hogarama/flyway/FlywayIntegrator.java | package com.gepardec.hogarama.flyway;
import org.flywaydb.core.Flyway;
import org.hibernate.boot.Metadata;
import org.hibernate.engine.spi.SessionFactoryImplementor;
import org.hibernate.integrator.spi.Integrator;
import org.hibernate.service.spi.SessionFactoryServiceRegistry;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.naming.InitialContext;
import javax.sql.DataSource;
public class FlywayIntegrator implements Integrator {
private static final Logger LOG = LoggerFactory.getLogger(FlywayIntegrator.class);
@Override
public void integrate(Metadata metadata, SessionFactoryImplementor sessionFactoryImplementor, SessionFactoryServiceRegistry sessionFactoryServiceRegistry) {
InitialContext ctx = null;
LOG.info("Starting flyway migration");
try {
ctx = new InitialContext();
DataSource datasource = (DataSource) ctx.lookup("java:jboss/datasources/Hogajama");
Flyway flyway = Flyway.configure().dataSource(datasource).schemas("hogajama").load();
flyway.migrate();
LOG.info("Flyway migration succeeded");
} catch (Exception e) {
LOG.error("Flyway migration failed", e);
}
}
@Override
public void disintegrate(SessionFactoryImplementor sessionFactoryImplementor, SessionFactoryServiceRegistry sessionFactoryServiceRegistry) {
}
}
| 1,404 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
ErrorModel.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/main/java/com/gepardec/hogarama/domain/ErrorModel.java | package com.gepardec.hogarama.domain;
import java.util.Objects;
import jakarta.validation.constraints.NotNull;
import com.fasterxml.jackson.annotation.JsonProperty;
import io.swagger.annotations.ApiModelProperty;
@jakarta.annotation.Generated(value = "io.swagger.codegen.languages.JavaResteasyEapServerCodegen", date = "2017-05-26T10:41:51.293+02:00")
public class ErrorModel {
private Integer code = null;
private String message = null;
/**
**/
@ApiModelProperty(example = "null", required = true, value = "")
@JsonProperty("code")
@NotNull
public Integer getCode() {
return code;
}
public void setCode(Integer code) {
this.code = code;
}
/**
**/
@ApiModelProperty(example = "null", required = true, value = "")
@JsonProperty("message")
@NotNull
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
ErrorModel errorModel = (ErrorModel) o;
return Objects.equals(code, errorModel.code) &&
Objects.equals(message, errorModel.message);
}
@Override
public int hashCode() {
return Objects.hash(code, message);
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("class ErrorModel {\n");
sb.append(" code: ").append(toIndentedString(code)).append("\n");
sb.append(" message: ").append(toIndentedString(message)).append("\n");
sb.append("}");
return sb.toString();
}
/**
* Convert the given object to string with each line indented by 4 spaces
* (except the first line).
*/
private String toIndentedString(Object o) {
if (o == null) {
return "null";
}
return o.toString().replace("\n", "\n ");
}
}
| 1,947 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
DateUtils.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/main/java/com/gepardec/hogarama/domain/DateUtils.java | package com.gepardec.hogarama.domain;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.Month;
import java.time.ZoneId;
import java.util.Date;
public class DateUtils {
private DateUtils(){
}
public static LocalDateTime toLocalDateTime(Date date) {
return LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
}
public static Date toDate(int year, Month month, int dayOfMonth, int hour, int minute) {
return toDate(LocalDateTime.of(year, month, dayOfMonth, hour, minute));
}
public static Date toDate(LocalDateTime time) {
return Date.from(time.atZone(ZoneId.systemDefault()).toInstant());
}
public static LocalDate toLocalDate(Date time) {
return LocalDate.from(time.toInstant().atZone(ZoneId.systemDefault()));
}
}
| 785 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
WateringConfigData.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/main/java/com/gepardec/hogarama/domain/watering/WateringConfigData.java | package com.gepardec.hogarama.domain.watering;
import org.mongodb.morphia.annotations.Entity;
import org.mongodb.morphia.annotations.Id;
@Entity("wateringConfig")
public class WateringConfigData implements WateringRule {
@Id
private String sensorName;
private String actorName;
private double lowWater;
private int waterDuration;
public WateringConfigData() {
}
public WateringConfigData(String id, String actorName, double lowWater, int waterDuration) {
super();
this.sensorName = id;
this.actorName = actorName;
this.lowWater = lowWater;
this.waterDuration = waterDuration;
}
@Override
public String getSensorName() {
return sensorName;
}
@Override
public String getActorName() {
return actorName;
}
@Override
public double getLowWater() {
return lowWater;
}
@Override
public int getWaterDuration() {
return waterDuration;
}
}
| 943 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
ActorControlService.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/main/java/com/gepardec/hogarama/domain/watering/ActorControlService.java | package com.gepardec.hogarama.domain.watering;
// TODO do we want to integrate this service into the new unitmanagement ActorService
public interface ActorControlService {
void sendActorMessage(String location, String sensorName, Integer duration);
}
| 255 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
WateringStrategy.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/main/java/com/gepardec/hogarama/domain/watering/WateringStrategy.java | package com.gepardec.hogarama.domain.watering;
import java.util.HashMap;
import java.util.Map;
import jakarta.enterprise.context.ApplicationScoped;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ApplicationScoped
public class WateringStrategy {
private static final Logger log = LoggerFactory.getLogger(WateringStrategy.class);
// Application scoped cache is not ideal, for now its good enough.
private Map<String, Double> cache = new HashMap<String, Double>();
public WateringStrategy() {
log.info("Initializing WateringStrategy");
}
private int waterDuration(WateringRule config, double avg) {
if ( avg < config.getLowWater() ) {
int dur = config.getWaterDuration();
log.info("water " + config.getActorName() + " for " + dur + " because average water value " + avg + " < " + config.getLowWater());
return dur;
}
log.debug("Don't water " + config.getActorName() + " because average water value " + avg + " not < " + config.getLowWater());
return 0;
}
public int computeWateringDuration(WateringRule config, double value) {
double avg = computeAverage(getCachedValue(config), value);
updateCache(config, avg);
return waterDuration(config,avg);
}
private double computeAverage(Double cachedValue, double value) {
if ( null == cachedValue ) {
cachedValue = value;
}
return (cachedValue * 2 + value) / 3;
}
private Double getCachedValue(WateringRule config) {
return cache.get(config.getSensorName());
}
private void updateCache(WateringRule config, double avg) {
cache.put(config.getSensorName(), avg);
}
}
| 1,730 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
WateringService.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/main/java/com/gepardec/hogarama/domain/watering/WateringService.java | package com.gepardec.hogarama.domain.watering;
import com.gepardec.hogarama.domain.metrics.Metrics;
import com.gepardec.hogarama.domain.sensor.SensorData;
import com.gepardec.hogarama.domain.sensor.SensorDataDAO;
import com.gepardec.hogarama.domain.sensor.SensorNormalizer;
import com.gepardec.hogarama.domain.sensor.SensorProperties;
import com.gepardec.hogarama.domain.unitmanagement.cache.ActorCache;
import com.gepardec.hogarama.domain.unitmanagement.cache.SensorCache;
import com.gepardec.hogarama.domain.unitmanagement.entity.Actor;
import com.gepardec.hogarama.domain.unitmanagement.entity.Sensor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import jakarta.inject.Inject;
import java.util.Optional;
public class WateringService {
public enum Config{
DEFAULT(1, 0.2, 5);
protected double lowWater;
protected int waterDuration;
Config( int measureInterval, double lowWater, int waterDuration) {
this.waterDuration = waterDuration;
this.lowWater = lowWater;
}
}
@Inject
public SensorDataDAO sensorDataDAO;
@Inject
public WateringRuleDAO configDao;
@Inject
SensorNormalizer sensorNormalizer;
@Inject
public ActorControlService actorSvc;
@Inject
public WateringStrategy watering;
@Inject
private ActorCache actorCache;
@Inject
private SensorCache sensorCache;
private static final Logger log = LoggerFactory.getLogger(WateringService.class);
public WateringService() {
}
protected WateringService(SensorDataDAO sensorDataDAO, SensorNormalizer normalizer, ActorControlService actorSvc, WateringStrategy watering, WateringRuleDAO configDao, ActorCache actorCache, SensorCache sensorCache) {
this.sensorDataDAO = sensorDataDAO;
this.sensorNormalizer = normalizer;
this.actorSvc = actorSvc;
this.watering = watering;
this.configDao = configDao;
this.actorCache = actorCache;
this.sensorCache = sensorCache;
}
private void invokeActorIfNeeded(WateringRule config, int dur, String location) {
if (dur > 0) {
Optional<Actor> optionalActor = actorCache.getByDeviceId(config.getActorName());
String actorName = optionalActor.isPresent() ? optionalActor.get().getName() : config.getActorName();
Optional<Sensor> optionalSensor = sensorCache.getByDeviceId(config.getSensorName());
String sensorName = optionalSensor.isPresent() ? optionalSensor.get().getName() : config.getSensorName();
Metrics.wateringEventsFired.labels(sensorName, actorName).inc();
Metrics.actorValues.labels(
actorName,
sensorName,
location
).set(dur);
actorSvc.sendActorMessage(location, config.getActorName(), dur);
}
}
private WateringRule getConfig(String sensorName) {
WateringRule wconfig = configDao.getBySensorName(sensorName);
if (null != wconfig) {
return wconfig;
}
wconfig = configDao.createWateringRule(sensorName, sensorName,
Config.DEFAULT.lowWater, Config.DEFAULT.waterDuration);
configDao.save(wconfig);
return wconfig;
}
private void sendMetrics(SensorData sensorData) {
SensorProperties sensorProps = new SensorProperties(sensorData, sensorCache);
Metrics.sensorValues.labels(
sensorProps.getSensorName(),
sensorProps.getDeviceId(),
sensorProps.getUnitName()
).set(sensorData.getValue());
}
public void processSensorData(SensorData sensorData) {
log.info("Receive sensorData: " + sensorData);
SensorData normalizedSensorData = sensorNormalizer.normalize(sensorData);
sensorDataDAO.save(normalizedSensorData);
sendMetrics(normalizedSensorData);
checkDataAndPerformWatering(normalizedSensorData);
}
private void checkDataAndPerformWatering(SensorData normalizedSensorData) {
WateringRule config = getConfig(normalizedSensorData.getSensorName());
invokeActorIfNeeded(config, watering.computeWateringDuration(config, normalizedSensorData.getValue()), normalizedSensorData.getLocation());
}
}
| 3,905 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
WateringData.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/main/java/com/gepardec/hogarama/domain/watering/WateringData.java | package com.gepardec.hogarama.domain.watering;
import org.apache.commons.lang3.builder.EqualsBuilder;
import org.mongodb.morphia.annotations.Entity;
import org.mongodb.morphia.annotations.Id;
import java.util.Date;
@Entity("watering")
public class WateringData {
@Id
private String id;
private Date time;
private String name;
private String location;
private Integer duration;
public WateringData() {
}
public WateringData(Date time, String name, String location, Integer duration){
this.time = time;
this.name = name;
this.location = location;
this.duration = duration;
}
public WateringData(String id, Date time, String name, String location, Integer duration) {
this(time, name, location,duration);
this.id = id;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public Date getTime() {
return time;
}
public void setTime(Date time) {
this.time = time;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getLocation() {
return location;
}
public void setLocation(String location) {
this.location = location;
}
public Integer getDuration() {
return duration;
}
public void setDuration(Integer duration) {
this.duration = duration;
}
@Override
public boolean equals(Object obj){
if(this == obj) return true;
if(obj == null) return false;
if(getClass() != obj.getClass()) return false;
WateringData other = (WateringData)obj;
return new EqualsBuilder()
.append(id, other.id)
.append(time, other.time)
.append(name, other.name)
.append(location, other.location)
.append(duration, other.duration)
.isEquals();
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((id == null) ? 0 : id.hashCode());
result = prime * result + ((time == null) ? 0 : time.hashCode());
result = prime * result + ((name == null) ? 0 : name.hashCode());
result = prime * result + ((location == null) ? 0 : location.hashCode());
result = prime * result + ((duration == null) ? 0 : duration.hashCode());
return result;
}
}
| 2,544 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
WateringDAO.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/main/java/com/gepardec/hogarama/domain/watering/WateringDAO.java | package com.gepardec.hogarama.domain.watering;
import java.util.Date;
import java.util.List;
public interface WateringDAO {
public List<WateringData> getWateringData(Integer maxNumber, String actorName, Date from, Date to);
}
| 232 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
WateringRule.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/main/java/com/gepardec/hogarama/domain/watering/WateringRule.java | package com.gepardec.hogarama.domain.watering;
public interface WateringRule {
String getSensorName();
String getActorName();
double getLowWater();
int getWaterDuration();
} | 195 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
WateringRuleDAO.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/main/java/com/gepardec/hogarama/domain/watering/WateringRuleDAO.java | package com.gepardec.hogarama.domain.watering;
public interface WateringRuleDAO {
void save(WateringRule wconf);
WateringRule getBySensorName(String id);
WateringRule createWateringRule(String sensorName, String actorName, double lowWater, int waterDuration);
} | 272 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
SensorNormalizer.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/main/java/com/gepardec/hogarama/domain/sensor/SensorNormalizer.java | package com.gepardec.hogarama.domain.sensor;
import java.util.List;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import com.gepardec.hogarama.domain.unitmanagement.cache.SensorCache;
@ApplicationScoped
public class SensorNormalizer {
@Inject
private SensorCache sensorDao;
public SensorData normalize(SensorData data) {
data.setValue(
mappingTypeOf(data)
.map(data.getValue())
);
return data;
}
private MappingType mappingTypeOf(SensorData data) {
return new SensorProperties(data, sensorDao).getMappingType();
}
public List<SensorData> normalize(List<SensorData> data) {
for (SensorData sensorData : data) {
normalize(sensorData);
}
return data;
}
public void setSensorCache(SensorCache sensorCache) {
this.sensorDao = sensorCache;
}
}
| 868 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
SensorDataDAO.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/main/java/com/gepardec/hogarama/domain/sensor/SensorDataDAO.java | package com.gepardec.hogarama.domain.sensor;
import java.util.Date;
import java.util.List;
public interface SensorDataDAO {
List<String> getAllSensors();
List<SensorData> getAllData(Integer maxNumber, String sensorName, Date from, Date to);
String getLocationBySensorName(String sensorName);
void save(SensorData sensorData);
}
| 361 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
SensorProperties.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/main/java/com/gepardec/hogarama/domain/sensor/SensorProperties.java | package com.gepardec.hogarama.domain.sensor;
import java.util.Optional;
import com.gepardec.hogarama.domain.unitmanagement.cache.SensorCache;
import com.gepardec.hogarama.domain.unitmanagement.entity.Sensor;
import com.gepardec.hogarama.domain.unitmanagement.entity.SensorType;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class SensorProperties {
private static final Logger LOG = LoggerFactory.getLogger(SensorProperties.class);
private SensorData data;
private String deviceId;
Optional<Sensor> sensor;
public SensorProperties(SensorData data, SensorCache dao) {
this.data = data;
deviceId = data.getSensorName();
sensor = dao.getByDeviceId(deviceId);
if (! sensor.isPresent()) {
LOG.warn("Sensor {} not found in database. We use MappingType from data. "
+ "You should create the sensor in the database!", data.getSensorName());
}
}
public String getDeviceId() {
return deviceId;
}
public String getSensorName() {
return sensor.isPresent() ? sensor.get().getName() : deviceId;
}
public String getUnitName() {
return sensor.isPresent() ? sensor.get().getUnit().getName() : data.getLocation();
}
public MappingType getMappingType() {
return sensor.isPresent() ?
sensor.get().getSensorType().getMappingType() :
SensorType.getMappingType(data.getType());
}
}
| 1,473 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
SensorNamesCache.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/main/java/com/gepardec/hogarama/domain/sensor/SensorNamesCache.java | package com.gepardec.hogarama.domain.sensor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import jakarta.ejb.Singleton;
import jakarta.ejb.Startup;
import jakarta.inject.Inject;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
@Startup
@Singleton
public class SensorNamesCache {
private static final int TEN_SECONDS = 10000;
private static final Logger log = LoggerFactory.getLogger(SensorNamesCache.class);
@Inject
private SensorDataDAO habaramaDao;
private List<String> sensorNames = new ArrayList<>();
private long cacheTime = 0;
public synchronized void loadSensorsFromDB() {
if(isStale()) {
log.info("Load the sensorNames from the database");
sensorNames.clear();
sensorNames = habaramaDao.getAllSensors();
cacheTime = (new Date()).getTime();
}
}
public List<String> getSensorNames() {
if(isStale()) {
loadSensorsFromDB();
}
return sensorNames;
}
private boolean isStale() {
return sensorNames.isEmpty() || ((new Date()).getTime() - cacheTime) > TEN_SECONDS ;
}
}
| 1,127 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
SensorData.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/main/java/com/gepardec/hogarama/domain/sensor/SensorData.java | package com.gepardec.hogarama.domain.sensor;
import java.util.Date;
import org.apache.commons.lang3.builder.EqualsBuilder;
import org.mongodb.morphia.annotations.Entity;
import org.mongodb.morphia.annotations.Id;
@Entity("habarama")
public class SensorData {
@Id
private String id;
private Date time;
private String sensorName;
private String type;
private double value;
private String location;
private String version;
public SensorData() {
}
public SensorData(String id, Date time, String sensorName, String type, double value, String location,
String version) {
super();
this.id = id;
this.time = time;
this.sensorName = sensorName;
this.type = type;
this.value = value;
this.location = location;
this.version = version;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public Date getTime() {
return time;
}
public void setTime(Date time) {
this.time = time;
}
public String getSensorName() {
return sensorName;
}
public void setSensorName(String sensorName) {
this.sensorName = sensorName;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public double getValue() {
return value;
}
public SensorData setValue(double value) {
this.value = value;
return this;
}
public String getLocation() {
return location;
}
public void setLocation(String location) {
this.location = location;
}
public String getVersion() {
return version;
}
public void setVersion(String version) {
this.version = version;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((id == null) ? 0 : id.hashCode());
result = prime * result + ((location == null) ? 0 : location.hashCode());
result = prime * result + ((sensorName == null) ? 0 : sensorName.hashCode());
result = prime * result + ((time == null) ? 0 : time.hashCode());
result = prime * result + ((type == null) ? 0 : type.hashCode());
long temp;
temp = Double.doubleToLongBits(value);
result = prime * result + (int) (temp ^ (temp >>> 32));
result = prime * result + ((version == null) ? 0 : version.hashCode());
return result;
}
@Override
public boolean equals(Object obj){
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
SensorData other = (SensorData) obj;
return new EqualsBuilder()
.append(id, other.id)
.append(location, other.location)
.append(sensorName, other.sensorName)
.append(time, other.time)
.append(type, other.type)
.append(Double.doubleToLongBits(value), Double.doubleToLongBits(other.value))
.append(version, other.version)
.build();
}
@Override
public String toString() {
return "SensorData [id=" + id + ", time=" + time + ", sensorName=" + sensorName + ", type=" + type + ", value="
+ value + ", location=" + location + ", version=" + version + "]";
}
}
| 3,041 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
MappingType.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/main/java/com/gepardec/hogarama/domain/sensor/MappingType.java | package com.gepardec.hogarama.domain.sensor;
import com.gepardec.hogarama.domain.unitmanagement.entity.SensorType;
/**
* Defines how sensor Values are mapped to a [0..1] interval.
* See {@link SensorType} for configuration of sensor types
*/
public enum MappingType {
/** The values are not mapped, just returned as received */
IDENTITY(),
/** The interval [0..100] is mapped linear to [0..1] */
LINEAR100(100.0),
/** The interval [0..1024] is mapped linear to [0..1] */
LINEAR1024(1024.0),
/** The interval [0..1024] is mapped linear to [1..0] */
INVERSE_LINEAR1024(1024.0, true);
private boolean identiy = false;
private double max;
private boolean inverse;
MappingType(){
this.identiy = true;
}
MappingType(Double max){
this.max = max;
}
MappingType(Double max, boolean inverse){
this(max);
this.inverse = inverse;
}
public double map(double value) {
if ( identiy ) {
return value;
}
double mapped = value / max;
if (inverse) {
mapped = 1 - mapped;
}
return mapped;
}
}
| 1,045 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
Metrics.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/main/java/com/gepardec/hogarama/domain/metrics/Metrics.java | package com.gepardec.hogarama.domain.metrics;
import io.prometheus.client.Counter;
import io.prometheus.client.Gauge;
import io.prometheus.client.Summary;
public class Metrics {
public static final Summary requestLatency = Summary.build()
.name("hogarama_requests_latency_seconds")
.help("Request latency in seconds.").labelNames("hogarama_module", "request_type").register();
public static final Counter requestFailures = Counter.build()
.name("hogarama_requests_failures_total")
.help("Request failures.").labelNames("hogarama_module", "request_type").register();
public static final Counter requestsTotal = Counter.build()
.name("hogarama_requests_total")
.help("Requests").labelNames("hogarama_module", "request_type").register();
public static final Counter exceptionsThrown = Counter.build()
.name("hogarama_exceptions_total")
.help("Exceptions thrown in hogajama").labelNames("hogarama_modul", "exception_name", "method").register();
public static final Counter wateringEventsFired = Counter.build()
.name("hogarama_watering_events_fired")
.help("Number of times a watering event has been fired")
.labelNames("sensor_name", "actor_name").register();
public static final Gauge sensorValues = Gauge.build()
.name("hogarama_sensor_value")
.help("Water Sensor Values.")
.labelNames("sensor_name", "device_id", "unit_name").register();
public static final Gauge actorValues = Gauge.build()
.name("hogarama_actor_value")
.help("Actor Values.")
.labelNames("actor_name", "senor_name", "unit_name").register();
}
| 1,755 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
BaseDAO.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/main/java/com/gepardec/hogarama/domain/unitmanagement/dao/BaseDAO.java | package com.gepardec.hogarama.domain.unitmanagement.dao;
import java.io.Serializable;
import java.util.List;
import java.util.Optional;
import jakarta.persistence.EntityManager;
import jakarta.persistence.PersistenceContext;
import com.gepardec.hogarama.domain.unitmanagement.entity.EntityNotFoundException;
public abstract class BaseDAO<T extends Serializable> {
@PersistenceContext
protected EntityManager entityManager;
public abstract Class<T> getEntityClass();
public Optional<T> getById(Long id) {
return Optional.ofNullable(entityManager.find(getEntityClass(), id));
}
public T getByIdNonOpt(Long id) {
return getById(id).orElseThrow(() -> new EntityNotFoundException(id, getEntityClass()));
}
public List<T> findAll() {
return entityManager.createQuery("from " + getEntityClass().getName())
.getResultList();
}
public void save(T entity) {
entityManager.persist(entity);
}
public void update(T entity) {
entityManager.merge(entity);
}
public void delete(T entity) {
entityManager.remove(entity);
}
public void deleteById(Long id) {
Optional<T> optionalEntity = getById(id);
optionalEntity.ifPresent(this::delete);
}
}
| 1,287 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
UnitDAO.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/main/java/com/gepardec/hogarama/domain/unitmanagement/dao/UnitDAO.java | package com.gepardec.hogarama.domain.unitmanagement.dao;
import com.gepardec.hogarama.domain.unitmanagement.entity.QUnit;
import com.gepardec.hogarama.domain.unitmanagement.entity.Sensor;
import com.gepardec.hogarama.domain.unitmanagement.entity.Unit;
import com.querydsl.jpa.impl.JPAQuery;
import jakarta.enterprise.context.Dependent;
import java.util.List;
@Dependent
public class UnitDAO extends BaseDAO<Unit> {
@Override
public Class<Unit> getEntityClass() {
return Unit.class;
}
public List<Unit> getUnitsForUser(Long userId) {
JPAQuery<Sensor> query = new JPAQuery<>(entityManager);
QUnit unit = QUnit.unit;
return query.select(unit).from(unit).where(unit.unit.user.id.eq(userId)).fetch();
}
}
| 757 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
PostgresWateringRuleDAO.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/main/java/com/gepardec/hogarama/domain/unitmanagement/dao/PostgresWateringRuleDAO.java | package com.gepardec.hogarama.domain.unitmanagement.dao;
import java.util.List;
import java.util.Optional;
import jakarta.inject.Inject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.gepardec.hogarama.annotations.PostgresDAO;
import com.gepardec.hogarama.domain.unitmanagement.cache.ActorCache;
import com.gepardec.hogarama.domain.unitmanagement.cache.SensorCache;
import com.gepardec.hogarama.domain.unitmanagement.entity.Actor;
import com.gepardec.hogarama.domain.unitmanagement.entity.LowWaterWateringRule;
import com.gepardec.hogarama.domain.unitmanagement.entity.Sensor;
import com.gepardec.hogarama.domain.unitmanagement.entity.Unit;
import com.gepardec.hogarama.domain.watering.WateringConfigData;
import com.gepardec.hogarama.domain.watering.WateringRule;
import com.gepardec.hogarama.domain.watering.WateringRuleDAO;
@PostgresDAO
public class PostgresWateringRuleDAO extends BaseDAO<LowWaterWateringRule> implements WateringRuleDAO{
private static final Logger LOG = LoggerFactory.getLogger(PostgresWateringRuleDAO.class);
@Inject
private ActorCache actorCache;
@Inject
private SensorCache sensorCache;
public PostgresWateringRuleDAO() {
}
@Override
public void save(WateringRule rule) {
if (!( rule instanceof LowWaterWateringRule)) {
LOG.warn("Watering rule is not a LowWaterWateringRule. Won't persist rule to database!");
return;
}
LowWaterWateringRule r = (LowWaterWateringRule)rule;
if ( !r.isValid() ) {
LOG.warn("Watering rule is not valid. Probably sensor or actor doesn't exist in database. Won't persist rule to database!");
return;
}
super.save(r);
}
@Override
public WateringRule getBySensorName(String sensorName) {
LOG.debug("getBySensorName " + sensorName);
List<LowWaterWateringRule> configs =
entityManager.createQuery("select r from LowWaterWateringRule r where r.sensor.deviceId=:sensorName")
.setParameter("sensorName", sensorName)
.getResultList();
if (configs.isEmpty()){
return null;
}
return configs.get(0);
}
@Override
public WateringRule createWateringRule(String sensorName, String actorName, double lowWater, int waterDuration) {
Sensor sensor = getSensor(sensorName);
Actor actor = getActor(actorName);
if ( null == sensor || null == actor ) {
// Sensors or actors are not created. We could create default Objects, but for now
// just create a temporary rule.
return new WateringConfigData(sensorName, actorName, lowWater, waterDuration);
}
return new LowWaterWateringRule(sensor, actor, getUnit(sensor), sensorName + "_" + actorName, lowWater, waterDuration);
}
@Override
public Class<LowWaterWateringRule> getEntityClass() {
return LowWaterWateringRule.class;
}
private Sensor getSensor(String sensorName) {
return sensorCache.getByDeviceId(sensorName).orElse(null);
}
private Actor getActor(String actorName) {
return actorCache.getByDeviceId(actorName).orElse(null);
}
private Unit getUnit(Sensor sensor) {
if ( null != sensor ) {
return sensor.getUnit();
}
return null;
}
} | 3,294 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
SensorDAO.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/main/java/com/gepardec/hogarama/domain/unitmanagement/dao/SensorDAO.java | package com.gepardec.hogarama.domain.unitmanagement.dao;
import java.util.List;
import java.util.Optional;
import jakarta.enterprise.context.Dependent;
import com.gepardec.hogarama.domain.unitmanagement.entity.User;
import com.gepardec.hogarama.domain.unitmanagement.entity.QSensor;
import com.gepardec.hogarama.domain.unitmanagement.entity.Sensor;
import com.querydsl.jpa.impl.JPAQuery;
@Dependent
public class SensorDAO extends BaseDAO<Sensor> {
@Override
public Class<Sensor> getEntityClass() {
return Sensor.class;
}
public List<Sensor> getAllSensorsForUser(User user) {
JPAQuery<Sensor> query = new JPAQuery<>(entityManager);
QSensor sensor = QSensor.sensor;
return query.select(sensor).from(sensor).where(sensor.unit.user.id.eq(user.getId())).fetch();
}
public Optional<Sensor> getByDeviceId(String deviceId) {
JPAQuery<Sensor> query = new JPAQuery<>(entityManager);
QSensor sensor = QSensor.sensor;
return Optional.ofNullable(query.select(sensor).from(sensor).where(sensor.deviceId.eq(deviceId)).fetchOne());
}
}
| 1,111 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
UserDAO.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/main/java/com/gepardec/hogarama/domain/unitmanagement/dao/UserDAO.java | package com.gepardec.hogarama.domain.unitmanagement.dao;
import com.gepardec.hogarama.domain.exception.TechnicalException;
import com.gepardec.hogarama.domain.unitmanagement.entity.User;
import com.gepardec.hogarama.domain.unitmanagement.entity.QUser;
import com.querydsl.core.NonUniqueResultException;
import com.querydsl.jpa.impl.JPAQuery;
import jakarta.enterprise.context.Dependent;
import java.util.Optional;
@Dependent
public class UserDAO extends BaseDAO<User> {
public Optional<User> getByKey(String userKey) {
QUser user = QUser.user;
JPAQuery<User> query = new JPAQuery<>(entityManager);
try {
User result = query.select(user).from(user).where(user.key.eq(userKey)).fetchOne();
return Optional.ofNullable(result);
} catch (NonUniqueResultException e) {
throw new TechnicalException("Multiple results for user with key " + userKey + " found.", e);
}
}
@Override
public Class<User> getEntityClass() {
return User.class;
}
}
| 1,041 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
ActorDAO.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/main/java/com/gepardec/hogarama/domain/unitmanagement/dao/ActorDAO.java | package com.gepardec.hogarama.domain.unitmanagement.dao;
import com.gepardec.hogarama.domain.unitmanagement.entity.Actor;
import com.gepardec.hogarama.domain.unitmanagement.entity.User;
import com.gepardec.hogarama.domain.unitmanagement.entity.QActor;
import com.querydsl.jpa.impl.JPAQuery;
import jakarta.enterprise.context.Dependent;
import java.util.List;
import java.util.Optional;
@Dependent
public class ActorDAO extends BaseDAO<Actor> {
@Override
public Class<Actor> getEntityClass() {
return Actor.class;
}
public List<Actor> getAllActorsForUser(User user) {
JPAQuery<Actor> query = new JPAQuery<>(entityManager);
QActor actor = QActor.actor;
return query.select(actor).from(actor).where(actor.unit.user.id.eq(user.getId())).fetch();
}
public Optional<Actor> getByDeviceId(String id) {
JPAQuery<Actor> query = new JPAQuery<>(entityManager);
QActor actor = QActor.actor;
return Optional.ofNullable(query.select(actor).from(actor).where(actor.deviceId.eq(id)).fetchOne());
}
}
| 1,073 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
RuleDAO.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/main/java/com/gepardec/hogarama/domain/unitmanagement/dao/RuleDAO.java | package com.gepardec.hogarama.domain.unitmanagement.dao;
import com.gepardec.hogarama.domain.unitmanagement.entity.LowWaterWateringRule;
import com.gepardec.hogarama.domain.unitmanagement.entity.User;
import com.gepardec.hogarama.domain.unitmanagement.entity.QLowWaterWateringRule;
import com.querydsl.jpa.impl.JPAQuery;
import jakarta.enterprise.context.Dependent;
import java.util.List;
import java.util.Optional;
@Dependent
public class RuleDAO extends BaseDAO<LowWaterWateringRule> {
@Override
public Class<LowWaterWateringRule> getEntityClass() {
return LowWaterWateringRule.class;
}
public List<LowWaterWateringRule> getAllRulesForUser(User user) {
JPAQuery<LowWaterWateringRule> query = new JPAQuery<>(entityManager);
QLowWaterWateringRule rule = QLowWaterWateringRule.lowWaterWateringRule;
return query.select(rule).from(rule).where(rule.unit.user.id.eq(user.getId())).fetch();
}
public Optional<LowWaterWateringRule> getBySensor(String sensorName) {
JPAQuery<LowWaterWateringRule> query = new JPAQuery<>(entityManager);
QLowWaterWateringRule rule = QLowWaterWateringRule.lowWaterWateringRule;
return Optional.ofNullable(query.select(rule).from(rule).where(rule.sensor.deviceId.eq(sensorName)).fetchOne());
}
}
| 1,309 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
UserContext.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/main/java/com/gepardec/hogarama/domain/unitmanagement/context/UserContext.java | package com.gepardec.hogarama.domain.unitmanagement.context;
import com.gepardec.hogarama.domain.unitmanagement.entity.User;
import com.gepardec.hogarama.domain.unitmanagement.entity.UserProfile;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import jakarta.enterprise.context.RequestScoped;
@RequestScoped
public class UserContext {
private static final Logger LOG = LoggerFactory.getLogger(UserContext.class);
private User user;
private UserProfile userProfile;
public User getUser() {
return user;
}
public void setUser(User user) {
LOG.debug("Set user with id {} and key {}.", user.getId(), user.getKey());
this.user = user;
}
public UserProfile getUserProfile() {
return userProfile;
}
public void setUserProfile(UserProfile userProfile) {
this.userProfile = userProfile;
}
}
| 884 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
Unit.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/main/java/com/gepardec/hogarama/domain/unitmanagement/entity/Unit.java | package com.gepardec.hogarama.domain.unitmanagement.entity;
import jakarta.persistence.*;
import java.io.Serializable;
import java.util.List;
@Entity
public class Unit implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(generator = "UnitIdGenerator", strategy = GenerationType.SEQUENCE)
@SequenceGenerator(name = "UnitIdGenerator", sequenceName = "seq_unit_id")
@Column(name = "id", nullable = false, updatable = false)
private Long id;
private String name;
private String description;
@Column(columnDefinition = "boolean default false", name = "is_default", nullable = false)
private Boolean defaultUnit;
@ManyToOne
@JoinColumn(name = "user_id")
private User user;
@OneToMany(mappedBy = "unit")
private List<Sensor> sensorList;
@OneToMany(mappedBy = "unit")
private List<Actor> actorList;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
public List<Sensor> getSensorList() {
return sensorList;
}
public void setSensorList(List<Sensor> sensorList) {
this.sensorList = sensorList;
}
public Boolean getDefaultUnit() {
return defaultUnit;
}
public void setDefaultUnit(Boolean defaultUnit) {
this.defaultUnit = defaultUnit;
}
public Boolean isDefaultUnit() {
return defaultUnit;
}
public List<Actor> getActorList() {
return actorList;
}
public void setActorList(List<Actor> actorList) {
this.actorList = actorList;
}
public static Unit createDefault(User user) {
Unit unit = new Unit();
unit.setDefaultUnit(true);
unit.setName("DEFAULT_UNIT");
unit.setDescription("Automatically created default unit.");
unit.setUser(user);
return unit;
}
}
| 2,329 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
Sensor.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/main/java/com/gepardec/hogarama/domain/unitmanagement/entity/Sensor.java | package com.gepardec.hogarama.domain.unitmanagement.entity;
import jakarta.persistence.*;
import java.io.Serializable;
@Entity
public class Sensor implements Serializable, Owned {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(generator = "SensorIdGenerator", strategy = GenerationType.SEQUENCE)
@SequenceGenerator(name = "SensorIdGenerator", sequenceName = "seq_sensor_id")
@Column(name = "id", nullable = false, updatable = false)
private Long id;
@ManyToOne
@JoinColumn(name = "sensor_type_id")
private SensorType sensorType;
private String name;
@Column(name = "device_id", unique = true)
private String deviceId;
@ManyToOne
@JoinColumn(name = "unit_id")
private Unit unit;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public SensorType getSensorType() {
return sensorType;
}
public void setSensorType(SensorType sensorType) {
this.sensorType = sensorType;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getDeviceId() {
return deviceId;
}
public void setDeviceId(String deviceId) {
this.deviceId = deviceId;
}
public Unit getUnit() {
return unit;
}
public void setUnit(Unit unit) {
this.unit = unit;
}
}
| 1,469 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
SensorType.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/main/java/com/gepardec/hogarama/domain/unitmanagement/entity/SensorType.java | package com.gepardec.hogarama.domain.unitmanagement.entity;
import java.io.Serializable;
import java.util.HashMap;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.SequenceGenerator;
import jakarta.persistence.Table;
import com.gepardec.hogarama.domain.sensor.MappingType;
@Entity
@Table(name = "sensor_type")
public class SensorType implements Serializable{
private static final long serialVersionUID = 1L;
public SensorType() {
}
public SensorType(Long id, String name) {
this.id = id;
this.name = name;
}
@Id
@GeneratedValue(generator = "SensorTypeGenerator", strategy = GenerationType.SEQUENCE)
@SequenceGenerator(name = "SensorTypeGenerator", sequenceName = "seq_sensor_type_id")
@Column(name = "id", nullable = false, updatable = false)
private Long id;
private String name;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@SuppressWarnings("serial")
private static final HashMap<String, MappingType> SENSORS = new HashMap<String, MappingType>() {{
put("IDENTITY", MappingType.IDENTITY);
put("LINEAR100", MappingType.LINEAR100);
put("LINEAR1024", MappingType.LINEAR1024);
put("INVERSE_LINEAR1024", MappingType.INVERSE_LINEAR1024);
put("Chinese Water Sensor", MappingType.INVERSE_LINEAR1024);
put("sparkfun", MappingType.LINEAR1024);
}};
public static MappingType getMappingType(String type) {
return SENSORS.getOrDefault(type, MappingType.LINEAR100);
}
public MappingType getMappingType() {
return getMappingType(name);
}
}
| 1,973 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
EntityNotFoundException.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/main/java/com/gepardec/hogarama/domain/unitmanagement/entity/EntityNotFoundException.java | package com.gepardec.hogarama.domain.unitmanagement.entity;
public class EntityNotFoundException extends RuntimeException{
private static final long serialVersionUID = 1L;
public EntityNotFoundException(Long id, Class<?> clazz){
super(String.format("Can't find entity of type %s with id %d!", clazz, id));
}
}
| 333 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
LowWaterWateringRule.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/main/java/com/gepardec/hogarama/domain/unitmanagement/entity/LowWaterWateringRule.java | package com.gepardec.hogarama.domain.unitmanagement.entity;
import java.io.Serializable;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.ManyToOne;
import jakarta.persistence.SequenceGenerator;
import jakarta.persistence.Table;
import jakarta.persistence.Transient;
import com.gepardec.hogarama.domain.watering.WateringRule;
@Entity
@Table(name = "low_water_watering_rule")
public class LowWaterWateringRule implements WateringRule, Serializable, Owned {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(generator = "WateringRuleGenerator", strategy = GenerationType.SEQUENCE)
@SequenceGenerator(name = "WateringRuleGenerator", sequenceName = "seq_rule_id")
@Column(name = "id", nullable = false, updatable = false)
private Long id;
@ManyToOne
@JoinColumn(name = "sensor_id")
private Sensor sensor;
@ManyToOne
@JoinColumn(name = "actor_id")
private Actor actor;
@ManyToOne
@JoinColumn(name = "unit_id")
private Unit unit;
@Column(name = "name")
private String name;
@Column(name = "description")
private String description;
@Column(name = "water_duration")
private int waterDuration;
@Column(name = "low_water")
private double lowWater;
@Transient
private boolean isValid;
public Sensor getSensor() {
return sensor;
}
public void setSensor(Sensor sensor) {
this.sensor = sensor;
}
public Actor getActor() {
return actor;
}
public void setActor(Actor actor) {
this.actor = actor;
}
public Unit getUnit() {
return unit;
}
public void setUnit(Unit unit) {
this.unit = unit;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Long getId() {
return id;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public void setId(Long id) {
this.id = id;
}
public void setWaterDuration(int waterDuration) {
this.waterDuration = waterDuration;
}
public void setLowWater(double lowWater) {
this.lowWater = lowWater;
}
public LowWaterWateringRule() {
this.isValid = true;
}
public LowWaterWateringRule(Sensor sensor, Actor actor, Unit unit, String name, double lowWater, int waterDuration) {
this.isValid = null != sensor && null != actor && null != unit;
this.sensor = sensor;
this.actor = actor;
this.unit = unit;
this.name = name;
this.lowWater = lowWater;
this.waterDuration = waterDuration;
}
@Override
public String getSensorName() {
if ( isValid ) {
return sensor.getDeviceId();
}
return "";
}
@Override
public String getActorName() {
if ( isValid ) {
return actor.getDeviceId();
}
return "";
}
@Override
public double getLowWater() {
return lowWater;
}
@Override
public int getWaterDuration() {
return waterDuration;
}
public boolean isValid() {
return isValid;
}
}
| 3,501 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
User.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/main/java/com/gepardec/hogarama/domain/unitmanagement/entity/User.java | package com.gepardec.hogarama.domain.unitmanagement.entity;
import com.gepardec.hogarama.domain.exception.TechnicalException;
import com.google.common.base.Preconditions;
import jakarta.persistence.*;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
@Entity
public class User implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(generator = "UserIdGenerator", strategy = GenerationType.SEQUENCE)
@SequenceGenerator(name = "UserIdGenerator", sequenceName = "seq_user_id")
@Column(name = "id", nullable = false, updatable = false)
private Long id;
@Column(name = "key")
private String key;
@OneToMany(mappedBy = "user")
private List<Unit> unitList;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getKey() {
return key;
}
public void setKey(String key) {
this.key = key;
}
public List<Unit> getUnitList() {
return unitList;
}
public void setUnitList(List<Unit> unitList) {
this.unitList = unitList;
}
public Unit getDefaultUnit() {
return unitList.stream()
.filter(Unit::isDefaultUnit)
.findFirst()
.orElseThrow(() ->
new TechnicalException(String.format("No Default unit given for user with id %s present.", getId())));
}
public void addUnit(Unit unit) {
Preconditions.checkNotNull(unit, "Unit must not be null.");
if (getUnitList() == null) {
unitList = new ArrayList<>();
}
unitList.add(unit);
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
User user = (User) o;
return Objects.equals(id, user.id) && Objects.equals(key, user.key);
}
@Override
public int hashCode() {
return Objects.hash(id, key);
}
}
| 2,093 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
UserProfile.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/main/java/com/gepardec/hogarama/domain/unitmanagement/entity/UserProfile.java | package com.gepardec.hogarama.domain.unitmanagement.entity;
import java.io.Serializable;
public class UserProfile implements Serializable {
private static final long serialVersionUID = 1L;
private String givenName;
private String familyName;
private String name;
private String email;
public String getGivenName() {
return givenName;
}
public void setGivenName(String givenName) {
this.givenName = givenName;
}
public String getFamilyName() {
return familyName;
}
public void setFamilyName(String familyName) {
this.familyName = familyName;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
}
| 902 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
Owned.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/main/java/com/gepardec/hogarama/domain/unitmanagement/entity/Owned.java | package com.gepardec.hogarama.domain.unitmanagement.entity;
import com.gepardec.hogarama.domain.exception.TechnicalException;
import java.util.stream.Collectors;
public interface Owned {
Unit getUnit();
default void verifyIsOwned(User user) {
if (!user.equals(getUnit().getUser())) {
throw new TechnicalException("Unit '"+getUnit()+"' doesn't belong to user '"+user.getId()+"'");
}
}
}
| 432 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
Actor.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/main/java/com/gepardec/hogarama/domain/unitmanagement/entity/Actor.java | package com.gepardec.hogarama.domain.unitmanagement.entity;
import jakarta.persistence.*;
import java.io.Serializable;
@Entity
public class Actor implements Serializable, Owned {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(generator = "ActorIdGenerator", strategy = GenerationType.SEQUENCE)
@SequenceGenerator(name = "ActorIdGenerator", sequenceName = "seq_actor_id")
@Column(name = "id", nullable = false, updatable = false)
private Long id;
private String name;
@Column(name = "device_id", unique = true)
private String deviceId;
@ManyToOne
@JoinColumn(name = "unit_id")
private Unit unit;
@Column(name = "queue_name")
private String queueName;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getDeviceId() {
return deviceId;
}
public void setDeviceId(String deviceId) {
this.deviceId = deviceId;
}
public Unit getUnit() {
return unit;
}
public void setUnit(Unit unit) {
this.unit = unit;
}
public String getQueueName() { return queueName; }
public void setQueueName(String queueName) { this.queueName = queueName; }
}
| 1,398 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
UnitService.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/main/java/com/gepardec/hogarama/domain/unitmanagement/service/UnitService.java | package com.gepardec.hogarama.domain.unitmanagement.service;
import com.gepardec.hogarama.domain.unitmanagement.context.UserContext;
import com.gepardec.hogarama.domain.unitmanagement.dao.UnitDAO;
import com.gepardec.hogarama.domain.unitmanagement.entity.Unit;
import jakarta.enterprise.event.Event;
import jakarta.inject.Inject;
import jakarta.ws.rs.NotFoundException;
import java.util.List;
public class UnitService {
@Inject
private UnitDAO dao;
@Inject
private UserContext userContext;
@Inject
Event<Unit> unitChanged;
public List<Unit> getUnitsForUser() {
return dao.getUnitsForUser(userContext.getUser().getId());
}
public void createUnit(Unit unit) {
dao.save(unit);
}
public void updateUnit(Unit unit) {
unitChanged.fire(unit);
dao.update(unit);
}
public void deleteUnit(Long unitId) {
Unit unit = this.dao.getById(unitId)
.orElseThrow(() -> new NotFoundException(String.format("Unit with id [%d] not found", unitId)));
unitChanged.fire(unit);
dao.delete(unit);
}
}
| 1,111 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
ActorService.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/main/java/com/gepardec/hogarama/domain/unitmanagement/service/ActorService.java | package com.gepardec.hogarama.domain.unitmanagement.service;
import com.gepardec.hogarama.domain.unitmanagement.context.UserContext;
import com.gepardec.hogarama.domain.unitmanagement.dao.ActorDAO;
import com.gepardec.hogarama.domain.unitmanagement.entity.Actor;
import jakarta.enterprise.event.Event;
import jakarta.inject.Inject;
import jakarta.ws.rs.NotFoundException;
import java.util.List;
public class ActorService {
@Inject
private ActorDAO dao;
@Inject
private UserContext userContext;
@Inject
Event<Actor> actorChanged;
public void createActor(Actor actor) {
actor.verifyIsOwned(userContext.getUser());
dao.save(actor);
}
public void deleteActor(Long actorId) {
Actor actor = this.dao.getById(actorId)
.orElseThrow(() -> new NotFoundException(String.format("Actor with id [%d] not found", actorId)));
actorChanged.fire(actor);
dao.delete(actor);
}
public void updateActor(Actor actor) {
actor.verifyIsOwned(userContext.getUser());
actorChanged.fire(actor);
dao.update(actor);
}
public List<Actor> getAllActorsForUser() {
return dao.getAllActorsForUser(userContext.getUser());
}
}
| 1,245 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
UserService.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/main/java/com/gepardec/hogarama/domain/unitmanagement/service/UserService.java | package com.gepardec.hogarama.domain.unitmanagement.service;
import com.gepardec.hogarama.domain.unitmanagement.dao.UserDAO;
import com.gepardec.hogarama.domain.unitmanagement.dao.UnitDAO;
import com.gepardec.hogarama.domain.unitmanagement.entity.User;
import com.gepardec.hogarama.domain.unitmanagement.entity.Unit;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import jakarta.enterprise.context.RequestScoped;
import jakarta.inject.Inject;
import jakarta.transaction.Transactional;
import jakarta.transaction.Transactional.TxType;
import java.util.Optional;
@RequestScoped
public class UserService {
private static final Logger LOG = LoggerFactory.getLogger(UserService.class);
@Inject
private UserDAO userDao;
@Inject
private UnitDAO unitDao;
public Optional<User> getRegisteredUser(String userKey) {
return userDao.getByKey(userKey);
}
/*
* Registers a User with user-key. In case the user already exists, it returns the existing user.
* The function starts its own transaction, but is not synchronized.
*/
@Transactional(TxType.REQUIRES_NEW)
public User getOrRegister(String userKey) {
LOG.info("getOrRegister user with key {}.", userKey);
return getRegisteredUser(userKey)
.orElseGet(() -> register(userKey));
}
private User register(String userKey) {
LOG.info("Register new user with key {}.", userKey);
User user = new User();
user.setKey(userKey);
userDao.save(user);
Unit defaultUnit = Unit.createDefault(user);
unitDao.save(defaultUnit);
user.addUnit(defaultUnit);
return user;
}
}
| 1,689 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
SensorService.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/main/java/com/gepardec/hogarama/domain/unitmanagement/service/SensorService.java | package com.gepardec.hogarama.domain.unitmanagement.service;
import java.util.List;
import jakarta.enterprise.event.Event;
import jakarta.inject.Inject;
import jakarta.ws.rs.NotFoundException;
import com.gepardec.hogarama.domain.unitmanagement.context.UserContext;
import com.gepardec.hogarama.domain.unitmanagement.dao.SensorDAO;
import com.gepardec.hogarama.domain.unitmanagement.entity.Sensor;
public class SensorService {
@Inject
private SensorDAO dao;
@Inject
private UserContext userContext;
@Inject
Event<Sensor> sensorChanged;
public void createSensor(Sensor sensor) {
sensor.verifyIsOwned(userContext.getUser());
dao.save(sensor);
}
public void deleteSensor(Long sensorId) {
Sensor sensor = this.dao.getById(sensorId)
.orElseThrow(() -> new NotFoundException(String.format("Sensor with id [%d] not found", sensorId)));
sensorChanged.fire(sensor);
dao.delete(sensor);
}
public void updateSensor(Sensor sensor) {
sensor.verifyIsOwned(userContext.getUser());
sensorChanged.fire(sensor);
dao.update(sensor);
}
public List<Sensor> getAllSensorsForUser() {
return dao.getAllSensorsForUser(userContext.getUser());
}
}
| 1,281 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
UserProfileService.java | /FileExtraction/Java_unseen/Gepardec_Hogarama/Hogajama/hogajama-domain/src/main/java/com/gepardec/hogarama/domain/unitmanagement/service/UserProfileService.java | package com.gepardec.hogarama.domain.unitmanagement.service;
import com.gepardec.hogarama.domain.unitmanagement.context.UserContext;
import com.gepardec.hogarama.domain.unitmanagement.entity.UserProfile;
import jakarta.inject.Inject;
import java.util.Optional;
public class UserProfileService {
@Inject
private UserContext userContext;
public UserProfile getUserProfile(){
return Optional.ofNullable(userContext.getUserProfile()).orElseThrow(() -> new RuntimeException("User Profile is not set"));
}
}
| 531 | Java | .java | Gepardec/Hogarama | 16 | 8 | 9 | 2016-09-11T08:42:43Z | 2024-05-01T15:08:12Z |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.