private WrappedSignedProperty convertToProperty(SkinModel skinData) { String encodedValue = skinData.getEncodedValue(); String signature = skinData.getSignature(); return WrappedSignedProperty.fromValues(SkinProperty.SKIN_KEY, encodedValue, signature); } }
@Override public String apply(String template, SkinModel skin) { if (template == null) { return null; } int rowId = skin.getRowId(); UUID ownerId = skin.getProfileId(); String ownerName = skin.getProfileName(); long timeFetched = skin.getTimestamp(); Map<TextureType, TextureModel> textures = skin.getTextures(); Optional<TextureModel> skinTexture = Optional.ofNullable(textures.get(TextureType.SKIN)); Optional<TextureModel> capeTexture = Optional.ofNullable(textures.get(TextureType.CAPE)); String skinUrl = skinTexture.map(TextureModel::getShortUrl).orElse(""); String slimModel = skinTexture.map(TextureModel::isSlim).map(slim -> "Alex").orElse("Steve"); String capeUrl = capeTexture.map(TextureModel::getShortUrl).orElse(" - "); String timeFormat = timeFormatter.format(Instant.ofEpochMilli(timeFetched)); return template.replace("{0}", Integer.toString(rowId)) .replace("{1}", ownerId.toString()) .replace("{2}", ownerName) .replace("{3}", timeFormat) .replace("{4}", skinUrl) .replace("{5}", slimModel) .replace("{6}", capeUrl); } }
private SkinModel parseSkinData(ResultSet resultSet) throws SQLException { int skinId = resultSet.getInt(1); long timestamp = resultSet.getLong(2); UUID uuid = UUIDTypeAdapter.parseId(resultSet.getString(3)); String name = resultSet.getString(4); boolean slimModel = resultSet.getBoolean(5); String skinUrl = resultSet.getString(6); String capeUrl = resultSet.getString(7); byte[] signature = resultSet.getBytes(8); return new SkinModel(skinId, timestamp, uuid, name, slimModel, skinUrl, capeUrl, signature); } }
public SkinModel checkAutoUpdate(SkinModel oldSkin) { if (oldSkin == null) { return null; } if (oldSkin.isOutdated(autoUpdateDiff)) { Optional<SkinModel> updatedSkin = skinApi.downloadSkin(oldSkin.getProfileId()); if (updatedSkin.isPresent() && !Objects.equals(updatedSkin.get(), oldSkin)) { return updatedSkin.get(); } } return oldSkin; }
skinData.getSaveLock().lock(); try { if (skinData.isSaved()) { TextureModel skinTexture = skinData.getTextures().get(SKIN); String skinUrl = ""; boolean slimModel = false; TextureModel capeTexture = skinData.getTextures().get(CAPE); String capeUrl = ""; if (capeTexture != null) { + " (?, ?, ?, ?, ?, ?, ?)", RETURN_GENERATED_KEYS)) { stmt.setLong(1, skinData.getTimestamp()); stmt.setString(2, UUIDTypeAdapter.toMojangId(skinData.getProfileId())); stmt.setString(3, skinData.getProfileName()); stmt.setBoolean(4, slimModel); stmt.setString(5, skinUrl); stmt.setString(6, capeUrl); stmt.setBytes(7, Base64.getDecoder().decode(skinData.getSignature())); skinData.setRowId(generatedKeys.getInt(1)); return true; logger.error("Failed to query skin data: {}", skinData, sqlEx); } finally { skinData.getSaveLock().unlock();
@Override public void writeTo(ByteArrayDataOutput out) { out.writeBoolean(allowed); out.writeInt(skin.getRowId()); out.writeUTF(skin.getEncodedValue()); out.writeUTF(skin.getSignature()); out.writeUTF(receiverUUID.toString()); }
@Override public void run() { UserPreference preferences = core.getStorage().getPreferences(receiverUUID); Optional<SkinModel> ownedSkin = preferences.getTargetSkin(); if (ownedSkin.isPresent()) { sendMessageInvoker("invalidate-request"); core.getSkinApi().downloadSkin(ownedSkin.get().getProfileId()).ifPresent(this::scheduleApplyTask); } else { sendMessageInvoker("dont-have-skin"); } }
private void loadDefaultSkins(Iterable<String> defaults) { for (String id : defaults) { Integer rowId = Ints.tryParse(id); if (rowId != null) { Optional.ofNullable(storage.getSkin(rowId)).ifPresent(defaultSkins::add); } UUID ownerUUID = UUID.fromString(id); SkinModel skinData = storage.getSkin(ownerUUID); if (skinData == null) { Optional<SkinModel> optSkin = skinApi.downloadSkin(ownerUUID); if (optSkin.isPresent()) { skinData = optSkin.get(); uuidCache.put(skinData.getProfileName(), skinData.getProfileId()); storage.save(skinData); } } defaultSkins.add(skinData); } }
@Override public void readFrom(ByteArrayDataInput in) { allowed = in.readBoolean(); int rowId = in.readInt(); String encodedValue = in.readUTF(); String encodedSignature = in.readUTF(); skin = SkinModel.createSkinFromEncoded(encodedValue, encodedSignature); skin.setRowId(rowId); receiverUUID = UUID.fromString(in.readUTF()); }
public Lock getSaveLock() { return getLazyLock().writeLock(); }
private Optional<SkinModel> parseSkinTexture(Reader reader) { TexturesModel texturesModel = gson.fromJson(reader, TexturesModel.class); SkinProperty[] properties = texturesModel.getProperties(); if (properties != null && properties.length > 0) { SkinProperty propertiesModel = properties[0]; //base64 encoded skin data String encodedSkin = propertiesModel.getValue(); String signature = propertiesModel.getSignature(); return Optional.of(SkinModel.createSkinFromEncoded(encodedSkin, signature)); } return Optional.empty(); } }
@Override public void writeTo(ByteArrayDataOutput out) { out.writeInt(targetSkin.getRowId()); out.writeUTF(targetSkin.getEncodedValue()); out.writeUTF(targetSkin.getSignature()); out.writeUTF(receiverUUD.toString()); out.writeBoolean(skinPerm); out.writeBoolean(isOp); }
private void checkPermissions(Player player, CheckPermMessage permMessage) { UUID receiverUUID = permMessage.getReceiverUUD(); boolean op = permMessage.isOp(); SkinModel targetSkin = permMessage.getTargetSkin(); UUID skinProfile = targetSkin.getProfileId(); boolean success = op || checkBungeePerms(player, receiverUUID, permMessage.isSkinPerm(), skinProfile); sendResultMessage(player, new PermResultMessage(success, targetSkin, receiverUUID)); }
@Override public void readFrom(ByteArrayDataInput in) { int rowId = in.readInt(); String encodedData = in.readUTF(); String encodedSignature = in.readUTF(); targetSkin = SkinModel.createSkinFromEncoded(encodedData, encodedSignature); targetSkin.setRowId(rowId); //continue on success only receiverUUD = UUID.fromString(in.readUTF()); skinPerm = in.readBoolean(); isOp = in.readBoolean(); }
public boolean isSaved() { getLazyLock().readLock().lock(); try { return rowId >= 0; } finally { getLazyLock().readLock().unlock(); } }
private Property[] toProperties(SkinModel targetSkin) { if (targetSkin == null) { return emptyProperties; } String encodedValue = targetSkin.getEncodedValue(); String signature = targetSkin.getSignature(); Property prop = new Property(SkinProperty.SKIN_KEY, encodedValue, signature); return new Property[]{prop}; } }
@Override public void onPluginMessageReceived(String channel, Player player, byte[] data) { ByteArrayDataInput dataInput = ByteStreams.newDataInput(data); CheckPermMessage message = new CheckPermMessage(); message.readFrom(dataInput); UUID receiverUUID = message.getReceiverUUD(); boolean op = message.isOp(); SkinModel targetSkin = message.getTargetSkin(); UUID skinProfile = targetSkin.getProfileId(); boolean success = op || checkBungeePerms(player, receiverUUID, message.isSkinPerm(), skinProfile); plugin.sendPluginMessage(player, new PermResultMessage(success, targetSkin, receiverUUID)); }
public int getRowId() { getLazyLock().readLock().lock(); try { return rowId; } finally { getLazyLock().readLock().unlock(); } }
@Override public void applyProperties(GameProfile profile, SkinModel targetSkin) { //remove existing skins profile.getPropertyMap().clear(); if (targetSkin != null) { GameProfileManager profileManager = Sponge.getServer().getGameProfileManager(); ProfileProperty profileProperty = profileManager.createProfileProperty(SkinProperty.SKIN_KEY , targetSkin.getEncodedValue(), targetSkin.getSignature()); profile.getPropertyMap().put(SkinProperty.SKIN_KEY, profileProperty); } }
public void setRowId(int rowId) { getLazyLock().writeLock().lock(); try { this.rowId = rowId; } finally { getLazyLock().writeLock().unlock(); } }