From 8543e139085399b24075977e9be27cd4b138e67a Mon Sep 17 00:00:00 2001 From: zeruth Date: Thu, 27 Jun 2019 17:14:30 -0400 Subject: [PATCH] Adds animation endpoint --- .../http/api/animation/AnimationClient.java | 149 +++++++++++++ .../http/api/animation/AnimationKey.java | 51 +++++ .../http/api/animation/AnimationRequest.java | 54 +++++ .../service/animation/AnimationCache.java | 45 ++++ .../animation/AnimationController.java | 92 ++++++++ .../service/animation/AnimationEndpoint.java | 206 ++++++++++++++++++ .../service/animation/AnimationEntry.java | 75 +++++++ 7 files changed, 672 insertions(+) create mode 100644 http-api/src/main/java/net/runelite/http/api/animation/AnimationClient.java create mode 100644 http-api/src/main/java/net/runelite/http/api/animation/AnimationKey.java create mode 100644 http-api/src/main/java/net/runelite/http/api/animation/AnimationRequest.java create mode 100644 http-service/src/main/java/net/runelite/http/service/animation/AnimationCache.java create mode 100644 http-service/src/main/java/net/runelite/http/service/animation/AnimationController.java create mode 100644 http-service/src/main/java/net/runelite/http/service/animation/AnimationEndpoint.java create mode 100644 http-service/src/main/java/net/runelite/http/service/animation/AnimationEntry.java diff --git a/http-api/src/main/java/net/runelite/http/api/animation/AnimationClient.java b/http-api/src/main/java/net/runelite/http/api/animation/AnimationClient.java new file mode 100644 index 0000000000..3fdab53094 --- /dev/null +++ b/http-api/src/main/java/net/runelite/http/api/animation/AnimationClient.java @@ -0,0 +1,149 @@ +/* + * Copyright (c) 2017, Adam + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package net.runelite.http.api.animation; + +import com.google.gson.JsonParseException; +import com.google.gson.reflect.TypeToken; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.util.List; +import net.runelite.http.api.RuneLiteAPI; +import okhttp3.Call; +import okhttp3.Callback; +import okhttp3.HttpUrl; +import okhttp3.MediaType; +import okhttp3.Request; +import okhttp3.RequestBody; +import okhttp3.Response; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class AnimationClient +{ + private static final MediaType JSON = MediaType.parse("application/json"); + + private static final Logger logger = LoggerFactory.getLogger(AnimationClient.class); + + public void submit(AnimationRequest animationRequest) + { + String json = RuneLiteAPI.GSON.toJson(animationRequest); + + HttpUrl url = RuneLiteAPI.getPlusApiBase().newBuilder() + .addPathSegment("animation") + .build(); + + logger.debug("Built URI: {}", url); + + Request request = new Request.Builder() + .post(RequestBody.create(JSON, json)) + .url(url) + .build(); + + try + { + try (Response response = RuneLiteAPI.RLP_CLIENT.newCall(request).execute()) + { + logger.debug("animation response " + response.code()); + } + } + catch (IOException e) + { + e.printStackTrace(); + } + + RuneLiteAPI.RLP_CLIENT.newCall(request).enqueue(new Callback() + { + @Override + public void onFailure(Call call, IOException e) + { + logger.warn("unable to submit animations", e); + } + + @Override + public void onResponse(Call call, Response response) + { + try + { + if (!response.isSuccessful()) + { + logger.debug("unsuccessful animation response"); + } + } + finally + { + response.close(); + } + } + }); + } + + public List get() throws IOException + { + HttpUrl url = RuneLiteAPI.getApiBase().newBuilder() + .addPathSegment("animation") + .build(); + + Request request = new Request.Builder() + .url(url) + .build(); + + try (Response response = RuneLiteAPI.CLIENT.newCall(request).execute()) + { + InputStream in = response.body().byteStream(); + // CHECKSTYLE:OFF + return RuneLiteAPI.GSON.fromJson(new InputStreamReader(in), new TypeToken>() + { + }.getType()); + // CHECKSTYLE:ON + } + catch (JsonParseException ex) + { + throw new IOException(ex); + } + } + + public AnimationKey get(int npcid) throws IOException + { + HttpUrl url = RuneLiteAPI.getApiBase().newBuilder() + .addPathSegment("animation") + .addPathSegment(Integer.toString(npcid)) + .build(); + + Request request = new Request.Builder() + .url(url) + .build(); + + try (Response response = RuneLiteAPI.CLIENT.newCall(request).execute()) + { + InputStream in = response.body().byteStream(); + return RuneLiteAPI.GSON.fromJson(new InputStreamReader(in), AnimationKey.class); + } + catch (JsonParseException ex) + { + throw new IOException(ex); + } + } +} diff --git a/http-api/src/main/java/net/runelite/http/api/animation/AnimationKey.java b/http-api/src/main/java/net/runelite/http/api/animation/AnimationKey.java new file mode 100644 index 0000000000..c4ce919326 --- /dev/null +++ b/http-api/src/main/java/net/runelite/http/api/animation/AnimationKey.java @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2017, Adam + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package net.runelite.http.api.animation; + +public class AnimationKey +{ + private int npcid; + private int[] animations; + + public int getNPCId() + { + return npcid; + } + + public void setNPCId(int npcid) + { + this.npcid = npcid; + } + + public int[] getAnimations() + { + return animations; + } + + public void setAnimations(int[] keys) + { + this.animations = keys; + } +} diff --git a/http-api/src/main/java/net/runelite/http/api/animation/AnimationRequest.java b/http-api/src/main/java/net/runelite/http/api/animation/AnimationRequest.java new file mode 100644 index 0000000000..9310c17ffc --- /dev/null +++ b/http-api/src/main/java/net/runelite/http/api/animation/AnimationRequest.java @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2017, Adam + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package net.runelite.http.api.animation; + +import java.util.ArrayList; +import java.util.List; + +public class AnimationRequest +{ + private int revision; + private List keys = new ArrayList<>(); + + public int getRevision() + { + return revision; + } + + public void setRevision(int revision) + { + this.revision = revision; + } + + public List getKeys() + { + return keys; + } + + public void addKey(AnimationKey key) + { + keys.add(key); + } +} diff --git a/http-service/src/main/java/net/runelite/http/service/animation/AnimationCache.java b/http-service/src/main/java/net/runelite/http/service/animation/AnimationCache.java new file mode 100644 index 0000000000..05f8e5ae11 --- /dev/null +++ b/http-service/src/main/java/net/runelite/http/service/animation/AnimationCache.java @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2018, Adam + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package net.runelite.http.service.animation; + +import lombok.AllArgsConstructor; +import lombok.Data; + +@Data +@AllArgsConstructor +class AnimationCache +{ + private int npcid; + private int anim1; + private int anim2; + private int anim3; + private int anim4; + private int anim5; + private int anim6; + private int anim7; + private int anim8; + private int anim9; + private int anim10; +} diff --git a/http-service/src/main/java/net/runelite/http/service/animation/AnimationController.java b/http-service/src/main/java/net/runelite/http/service/animation/AnimationController.java new file mode 100644 index 0000000000..c588b8193d --- /dev/null +++ b/http-service/src/main/java/net/runelite/http/service/animation/AnimationController.java @@ -0,0 +1,92 @@ +/* + * Copyright (c) 2018, Adam + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package net.runelite.http.service.animation; + +import java.util.List; +import java.util.stream.Collectors; +import net.runelite.http.api.animation.AnimationKey; +import net.runelite.http.api.animation.AnimationRequest; +import net.runelite.http.service.util.exception.NotFoundException; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.PathVariable; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestMapping; +import static org.springframework.web.bind.annotation.RequestMethod.POST; +import org.springframework.web.bind.annotation.RestController; + +@RestController +@RequestMapping("/animation") +public class AnimationController +{ + @Autowired + private AnimationEndpoint animationService; + + @RequestMapping(method = POST) + public void submit(@RequestBody AnimationRequest animationRequest) + { + animationService.submit(animationRequest); + } + + @GetMapping + public List get() + { + return animationService.get().stream() + .map(AnimationController::entryToKey) + .collect(Collectors.toList()); + } + + @GetMapping("/{npcid}") + public AnimationKey getRegion(@PathVariable int npcid) + { + AnimationEntry animationEntry = animationService.getNPC(npcid); + if (animationEntry == null) + { + throw new NotFoundException(); + } + + return entryToKey(animationEntry); + } + + private static AnimationKey entryToKey(AnimationEntry xe) + { + AnimationKey animationKey = new AnimationKey(); + animationKey.setNPCId(xe.getNPCId()); + animationKey.setAnimations(new int[] + { + xe.getAnimations()[0], + xe.getAnimations()[1], + xe.getAnimations()[2], + xe.getAnimations()[3], + xe.getAnimations()[4], + xe.getAnimations()[5], + xe.getAnimations()[6], + xe.getAnimations()[7], + xe.getAnimations()[8], + xe.getAnimations()[9], + }); + return animationKey; + } +} diff --git a/http-service/src/main/java/net/runelite/http/service/animation/AnimationEndpoint.java b/http-service/src/main/java/net/runelite/http/service/animation/AnimationEndpoint.java new file mode 100644 index 0000000000..57b54c98d1 --- /dev/null +++ b/http-service/src/main/java/net/runelite/http/service/animation/AnimationEndpoint.java @@ -0,0 +1,206 @@ +/* + * Copyright (c) 2017, Adam + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package net.runelite.http.service.animation; + +import com.google.common.cache.Cache; +import com.google.common.cache.CacheBuilder; +import java.util.List; +import net.runelite.http.api.animation.AnimationKey; +import net.runelite.http.api.animation.AnimationRequest; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Qualifier; +import org.springframework.stereotype.Service; +import org.sql2o.Connection; +import org.sql2o.Query; +import org.sql2o.Sql2o; + +@Service +public class AnimationEndpoint +{ + private static final String CREATE_SQL = "CREATE TABLE IF NOT EXISTS `animation` (\n" + + " `id` int(11) NOT NULL AUTO_INCREMENT,\n" + + " `region` int(11) NOT NULL,\n" + + " `time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,\n" + + " `rev` int(11) NOT NULL,\n" + + " `anim1` int(11),\n" + + " `anim2` int(11),\n" + + " `anim3` int(11),\n" + + " `anim4` int(11),\n" + + " `anim5` int(11),\n" + + " `anim6` int(11),\n" + + " `anim7` int(11),\n" + + " `anim8` int(11),\n" + + " `anim9` int(11),\n" + + " `anim10` int(11),\n" + + " PRIMARY KEY (`id`),\n" + + " KEY `npcid` (`npcid`,`time`)\n" + + ") ENGINE=InnoDB"; + + private final Sql2o sql2o; + + private final Cache keyCache = CacheBuilder.newBuilder() + .maximumSize(1024) + .build(); + + @Autowired + public AnimationEndpoint( + @Qualifier("Runelite SQL2O") Sql2o sql2o + ) + { + this.sql2o = sql2o; + + try (Connection con = sql2o.beginTransaction()) + { + con.createQuery(CREATE_SQL) + .executeUpdate(); + } + } + + private AnimationEntry findLatestAnimations(Connection con, int npcid) + { + return con.createQuery("select npcid, time, anim1, anim2, anim3, anim4, anim5, anim6, anim7, anim8, anim9, anim10 from animation " + + "where npcid = :npcid " + + "order by time desc " + + "limit 1") + .addParameter("npcid", npcid) + .executeAndFetchFirst(AnimationEntry.class); + } + + public void submit(AnimationRequest animationRequest) + { + boolean cached = true; + for (AnimationKey key : animationRequest.getKeys()) + { + int npcid = key.getNPCId(); + int[] animations = key.getAnimations(); + + AnimationCache animationCache = keyCache.getIfPresent(npcid); + if (animationCache == null + || animationCache.getAnim1() != animations[0] + || animationCache.getAnim2() != animations[1] + || animationCache.getAnim3() != animations[2] + || animationCache.getAnim4() != animations[3] + || animationCache.getAnim5() != animations[4] + || animationCache.getAnim6() != animations[5] + || animationCache.getAnim7() != animations[6] + || animationCache.getAnim8() != animations[7] + || animationCache.getAnim9() != animations[8] + || animationCache.getAnim10() != animations[9]) + { + cached = false; + keyCache.put(npcid, new AnimationCache(npcid, animations[0], animations[1], animations[2], animations[3], animations[4], animations[5], animations[6], animations[7], animations[8], animations[9])); + } + } + + if (cached) + { + return; + } + + try (Connection con = sql2o.beginTransaction()) + { + Query query = null; + + for (AnimationKey key : animationRequest.getKeys()) + { + int npcid = key.getNPCId(); + int[] animations = key.getAnimations(); + + AnimationEntry animationEntry = findLatestAnimations(con, npcid); + + if (animations.length != 10) + { + throw new IllegalArgumentException("Key length must be 10"); + } + + // already have these? + if (animationEntry != null + && animationEntry.getAnimations()[0] == animations[0] + && animationEntry.getAnimations()[1] == animations[1] + && animationEntry.getAnimations()[2] == animations[2] + && animationEntry.getAnimations()[3] == animations[3] + && animationEntry.getAnimations()[4] == animations[4] + && animationEntry.getAnimations()[5] == animations[5] + && animationEntry.getAnimations()[6] == animations[6] + && animationEntry.getAnimations()[7] == animations[7] + && animationEntry.getAnimations()[8] == animations[8] + && animationEntry.getAnimations()[9] == animations[9]) + { + continue; + } + + + if (query == null) + { + query = con.createQuery("insert into animation (npcid, rev, anim1, anim2, anim3, anim4, anim5, anim6, anim7, anim8, anim9, anim10) " + + "values (:npcid, :rev, :anim1, :anim2, :anim3, :anim4, anim5, anim6, anim7, anim8, anim9, anim10)"); + } + + query.addParameter("npcid", npcid) + .addParameter("rev", animationRequest.getRevision()) + .addParameter("anim1", animations[0]) + .addParameter("anim2", animations[1]) + .addParameter("anim3", animations[2]) + .addParameter("anim4", animations[3]) + .addParameter("anim5", animations[4]) + .addParameter("anim6", animations[5]) + .addParameter("anim7", animations[6]) + .addParameter("anim8", animations[7]) + .addParameter("anim9", animations[8]) + .addParameter("anim10", animations[9]) + .addToBatch(); + } + + if (query != null) + { + query.executeBatch(); + con.commit(false); + } + } + } + + public List get() + { + try (Connection con = sql2o.open()) + { + return con.createQuery( + "select t1.npcid, t2.time, t2.rev, t2.anim1, t2.anim2, t2.anim3, t2.anim4, t2.anim5, t2.anim6, t2.anim7, t2.anim8, t2.anim9, t2.anim10 from " + + "(select npcid,max(id) as id from animation group by npcid) t1 " + + "join animation t2 on t1.id = t2.id") + .executeAndFetch(AnimationEntry.class); + } + } + + public AnimationEntry getNPC(int npcid) + { + try (Connection con = sql2o.open()) + { + return con.createQuery("select npcid, time, rev, anim1, anim2, anim3, anim4, anim5, anim6, anim7, anim8, anim9, anim10 from animation " + + "where npcid = :npcid order by time desc limit 1") + .addParameter("npcid", npcid) + .executeAndFetchFirst(AnimationEntry.class); + } + } +} diff --git a/http-service/src/main/java/net/runelite/http/service/animation/AnimationEntry.java b/http-service/src/main/java/net/runelite/http/service/animation/AnimationEntry.java new file mode 100644 index 0000000000..af8ed67257 --- /dev/null +++ b/http-service/src/main/java/net/runelite/http/service/animation/AnimationEntry.java @@ -0,0 +1,75 @@ +/* + * Copyright (c) 2017, Adam + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package net.runelite.http.service.animation; + +import java.time.Instant; + +public class AnimationEntry +{ + private int npcid; + private Instant time; + private int rev; + private int[] animations; + + public int getNPCId() + { + return npcid; + } + + public void setNPCId(int npcid) + { + this.npcid = npcid; + } + + public Instant getTime() + { + return time; + } + + public void setTime(Instant time) + { + this.time = time; + } + + public int getRev() + { + return rev; + } + + public void setRev(int rev) + { + this.rev = rev; + } + + public int[] getAnimations() + { + return animations; + } + + public void setAnimations(int[] animations) + { + this.animations = animations; + } +}