function
stringlengths 87
5.09k
| validationType
stringclasses 2
values | fixed
stringlengths 289
7.12k
|
|---|---|---|
@EventHandler
public void on(PlayerJoinEvent event) {
UpdateChecker updateChecker = UpdateChecker.init(WirelessRedstone.getInstance());
if (updateChecker.getLastResult() == null) {
return;
}
if (updateChecker.getLastResult().updateAvailable()) {
Bukkit.getScheduler().runTaskLater(WirelessRedstone.getInstance(), () -> Utils.sendFeedback(WirelessRedstone.getStrings().newUpdate.replaceAll("%%NEWVERSION", updateChecker.getLastResult().getNewestVersion()).replaceAll("%%URL", updateChecker.getLastResult().getUrl()), event.getPlayer(), false), 1L);
}
}
|
annotation
|
@EventHandler
public void on(PlayerJoinEvent<method*start>org.bukkit.event.player.PlayerJoinEvent<method*end> event) {
if (!event.getPlayer().hasPermission(Permissions.isWirelessAdmin)) {
return;
}
UpdateChecker updateChecker = UpdateChecker.init(WirelessRedstone.getInstance());
if (updateChecker.getLastResult() == null) {
return;
}
if (!updateChecker.getLastResult().updateAvailable()) {
return;
}
Bukkit<method*start>org.bukkit.Bukkit<method*end>.getScheduler().runTaskLater(WirelessRedstone.getInstance(), () -> Utils.sendFeedback(WirelessRedstone.getStrings().newUpdate.replaceAll("%%NEWVERSION", updateChecker.getLastResult().getNewestVersion()).replaceAll("%%URL", updateChecker.getLastResult().getUrl()), event.getPlayer(), false), 1L);
}
|
@HiveWebsocketAuth
public void processDeviceTypeCount(JsonObject request, WebSocketSession session) {
CountDeviceTypeRequest countDeviceTypeRequest = CountDeviceTypeRequest.createCountDeviceTypeRequest(request);
WebSocketResponse response = new WebSocketResponse();
deviceTypeService.count(countDeviceTypeRequest).thenAccept(count -> {
logger.debug("Device type count request proceed successfully.");
response.addValue(Constants.COUNT, count.getCount(), null);
webSocketClientHandler.sendMessage(request, response, session);
});
}
|
annotation
|
@HiveWebsocketAuth
@PreAuthorize<method*start>org.springframework.security.access.prepost.PreAuthorize<method*end>("isAuthenticated() and hasPermission(null, 'GET_DEVICE_TYPE')")
public void processDeviceTypeCount(JsonObject<method*start>com.google.gson.JsonObject<method*end> request, WebSocketSession<method*start>org.springframework.web.socket.WebSocketSession<method*end> session) {
CountDeviceTypeRequest<method*start>com.devicehive.model.rpc.CountDeviceTypeRequest<method*end> countDeviceTypeRequest = CountDeviceTypeRequest.createCountDeviceTypeRequest<method*start>com.devicehive.model.rpc.CountDeviceTypeRequest.createCountDeviceTypeRequest<method*end>(request);
WebSocketResponse response = new WebSocketResponse();
deviceTypeService.count<method*start>com.devicehive.service.DeviceTypeService.count<method*end>(countDeviceTypeRequest).thenAccept<method*start>java.util.concurrent.CompletableFuture.thenAccept<method*end>(count -> {
logger.debug<method*start>org.slf4j.Logger.debug<method*end>("Device type count request proceed successfully.");
response.addValue<method*start>com.devicehive.websockets.converters.WebSocketResponse.addValue<method*end>(COUNT<method*start>com.devicehive.configuration.Constants.COUNT<method*end>, count.getCount<method*start>datomic.aggregation.count.getCount<method*end>(), null);
webSocketClientHandler.sendMessage<method*start>com.devicehive.messages.handler.WebSocketClientHandler.sendMessage<method*end>(request, response, session);
});
}
|
private File<method*start>java.io.File<method*end> getSourceFile() {
File<method*start>java.io.File<method*end> sourceFile = new File<method*start>java.io.File<method*end>(owner.getRootDir<method*start>hudson.model.Run<java.lang.Object,java.lang.Object>.getRootDir<method*end>(), DefaultSourceFileResolver.DEFAULT_SOURCE_CODE_STORE_DIRECTORY<method*start>io.jenkins.plugins.coverage.source.DefaultSourceFileResolver.DEFAULT_SOURCE_CODE_STORE_DIRECTORY<method*end> + sanitizeFilename<method*start>io.jenkins.plugins.coverage.targets.CoverageResult.sanitizeFilename<method*end>(relativeSourcePath));
if (sourceFile.exists<method*start>java.io.File.exists<method*end>()) {
return sourceFile;
}
// keep compatibility
sourceFile = new File<method*start>java.io.File<method*end>(owner.getRootDir<method*start>hudson.model.Run<java.lang.Object,java.lang.Object>.getRootDir<method*end>(), DefaultSourceFileResolver.DEFAULT_SOURCE_CODE_STORE_DIRECTORY<method*start>io.jenkins.plugins.coverage.source.DefaultSourceFileResolver.DEFAULT_SOURCE_CODE_STORE_DIRECTORY<method*end> + relativeSourcePath);
if (sourceFile.exists<method*start>java.io.File.exists<method*end>()) {
return sourceFile;
}
// try to normalize file path
return Paths.get<method*start>java.nio.file.Paths.get<method*end>(sourceFile.getPath<method*start>java.io.File.getPath<method*end>()).normalize<method*start>java.nio.file.Path.normalize<method*end>().toFile<method*start>java.nio.file.Path.toFile<method*end>();
}
return null;
}
|
conventional
|
private File<method*start>java.io.File<method*end> getSourceFile() {
if (hasPermission<method*start>io.jenkins.plugins.coverage.targets.CoverageResult.hasPermission<method*end>()) {
File<method*start>java.io.File<method*end> sourceFile = new File<method*start>java.io.File<method*end>(owner.getRootDir<method*start>hudson.model.Run<java.lang.Object,java.lang.Object>.getRootDir<method*end>(), DefaultSourceFileResolver.DEFAULT_SOURCE_CODE_STORE_DIRECTORY<method*start>io.jenkins.plugins.coverage.source.DefaultSourceFileResolver.DEFAULT_SOURCE_CODE_STORE_DIRECTORY<method*end> + sanitizeFilename<method*start>io.jenkins.plugins.coverage.targets.CoverageResult.sanitizeFilename<method*end>(relativeSourcePath));
if (sourceFile.exists<method*start>java.io.File.exists<method*end>()) {
return sourceFile;
}
// keep compatibility
sourceFile = new File<method*start>java.io.File<method*end>(owner.getRootDir<method*start>hudson.model.Run<java.lang.Object,java.lang.Object>.getRootDir<method*end>(), DefaultSourceFileResolver.DEFAULT_SOURCE_CODE_STORE_DIRECTORY<method*start>io.jenkins.plugins.coverage.source.DefaultSourceFileResolver.DEFAULT_SOURCE_CODE_STORE_DIRECTORY<method*end> + relativeSourcePath);
if (sourceFile.exists<method*start>java.io.File.exists<method*end>()) {
return sourceFile;
}
// try to normalize file path
return Paths.get<method*start>java.nio.file.Paths.get<method*end>(sourceFile.getPath<method*start>java.io.File.getPath<method*end>()).normalize<method*start>java.nio.file.Path.normalize<method*end>().toFile<method*start>java.nio.file.Path.toFile<method*end>();
}
return null;
}
|
@Override
public ItemUseHandler<method*start>me.mrCookieSlime.Slimefun.Objects.handlers.ItemUseHandler<method*end> getItemHandler() {
return e -> {
Optional<method*start>java.util.Optional<method*end><Block<method*start>org.bukkit.block.Block<method*end>> block = e.getClickedBlock<method*start>e.getClickedBlock<method*end>();
if (block.isPresent<method*start>java.util.Optional.isPresent<method*end>()) {
Block<method*start>org.bukkit.block.Block<method*end> b = block.get<method*start>java.util.Optional.get<method*end>();
ItemStack<method*start>org.bukkit.inventory.ItemStack<method*end> output = randomizer.getRandom<method*start>io.github.thebusybiscuit.cscorelib2.collections.RandomizedSet<org.bukkit.inventory.ItemStack>.getRandom<method*end>();
b.getWorld<method*start>org.bukkit.block.Block.getWorld<method*end>().playEffect(b.getLocation<method*start>org.bukkit.block.Block.getLocation<method*end>(), Effect.STEP_SOUND<method*start>org.bukkit.Effect.STEP_SOUND<method*end>, b.getType<method*start>org.bukkit.block.Block.getType<method*end>());
b.setType<method*start>org.bukkit.block.Block.setType<method*end>(Material.AIR<method*start>org.bukkit.Material.AIR<method*end>);
if (output.getType<method*start>org.bukkit.inventory.ItemStack.getType<method*end>() != Material.AIR<method*start>org.bukkit.Material.AIR<method*end>) {
b.getWorld<method*start>org.bukkit.block.Block.getWorld<method*end>().dropItemNaturally(b.getLocation<method*start>org.bukkit.block.Block.getLocation<method*end>(), output.clone<method*start>org.bukkit.inventory.ItemStack.clone<method*end>());
}
}
}
e.cancel<method*start>e.cancel<method*end>();
};
}
|
conventional
|
@Override
public ItemUseHandler<method*start>me.mrCookieSlime.Slimefun.Objects.handlers.ItemUseHandler<method*end> getItemHandler() {
return e -> {
Optional<method*start>java.util.Optional<method*end><Block<method*start>org.bukkit.block.Block<method*end>> block = e.getClickedBlock<method*start>e.getClickedBlock<method*end>();
if (block.isPresent<method*start>java.util.Optional.isPresent<method*end>()) {
Block<method*start>org.bukkit.block.Block<method*end> b = block.get<method*start>java.util.Optional.get<method*end>();
if (b.getType<method*start>org.bukkit.block.Block.getType<method*end>() == Material.GRAVEL<method*start>org.bukkit.Material.GRAVEL<method*end> && SlimefunPlugin.getProtectionManager<method*start>me.mrCookieSlime.Slimefun.SlimefunPlugin.getProtectionManager<method*end>().hasPermission(e.getPlayer<method*start>e.getPlayer<method*end>(), b.getLocation<method*start>org.bukkit.block.Block.getLocation<method*end>(), ProtectableAction.BREAK_BLOCK<method*start>io.github.thebusybiscuit.cscorelib2.protection.ProtectableAction.BREAK_BLOCK<method*end>)) {
ItemStack<method*start>org.bukkit.inventory.ItemStack<method*end> output = randomizer.getRandom<method*start>io.github.thebusybiscuit.cscorelib2.collections.RandomizedSet<org.bukkit.inventory.ItemStack>.getRandom<method*end>();
b.getWorld<method*start>org.bukkit.block.Block.getWorld<method*end>().playEffect(b.getLocation<method*start>org.bukkit.block.Block.getLocation<method*end>(), Effect.STEP_SOUND<method*start>org.bukkit.Effect.STEP_SOUND<method*end>, b.getType<method*start>org.bukkit.block.Block.getType<method*end>());
b.setType<method*start>org.bukkit.block.Block.setType<method*end>(Material.AIR<method*start>org.bukkit.Material.AIR<method*end>);
if (output.getType<method*start>org.bukkit.inventory.ItemStack.getType<method*end>() != Material.AIR<method*start>org.bukkit.Material.AIR<method*end>) {
b.getWorld<method*start>org.bukkit.block.Block.getWorld<method*end>().dropItemNaturally(b.getLocation<method*start>org.bukkit.block.Block.getLocation<method*end>(), output.clone<method*start>org.bukkit.inventory.ItemStack.clone<method*end>());
}
}
}
e.cancel<method*start>e.cancel<method*end>();
};
}
|
@EventHandler(ignoreCancelled = true)
public void onPlayerCreateNPC(PlayerCreateNPCEvent event) {
EconomyResponse response = provider.withdrawPlayer(event.getCreator(), cost);
if (!response.transactionSuccess()) {
event.setCancelled(true);
event.setCancelReason(response.errorMessage);
return;
}
String formattedCost = provider.format(cost);
Messaging.sendTr(event.getCreator(), Messages.MONEY_WITHDRAWN, formattedCost);
}
|
annotation
|
@EventHandler(ignoreCancelled = true)
public void onPlayerCreateNPC(PlayerCreateNPCEvent<method*start>net.citizensnpcs.api.event.PlayerCreateNPCEvent<method*end> event) {
boolean hasAccount = provider<method*start>net.citizensnpcs.PaymentListener.provider<method*end>.hasAccount(event.getCreator());
if (!hasAccount || event.getCreator().hasPermission("citizens.npc.ignore-cost"))
return;
double cost = Setting<method*start>net.citizensnpcs.Settings.Setting<method*end>.NPC_COST.asDouble();
EconomyResponse<method*start>net.milkbowl.vault.economy.EconomyResponse<method*end> response = provider<method*start>net.citizensnpcs.PaymentListener.provider<method*end>.withdrawPlayer(event.getCreator(), cost);
if (!response.transactionSuccess()) {
event.setCancelled(true);
event.setCancelReason(response.errorMessage);
return;
}
String<method*start>java.lang.String<method*end> formattedCost = provider<method*start>net.citizensnpcs.PaymentListener.provider<method*end>.format(cost);
Messaging<method*start>net.citizensnpcs.api.util.Messaging<method*end>.sendTr(event.getCreator(), Messages<method*start>net.citizensnpcs.util.Messages<method*end>.MONEY_WITHDRAWN, formattedCost);
}
|
default boolean canWrite(User<method*start>org.javacord.api.entity.user.User<method*end> user) {
Optional<method*start>java.util.Optional<method*end><PrivateChannel> privateChannel = asPrivateChannel();
Optional<method*start>java.util.Optional<method*end><GroupChannel> groupChannel = asGroupChannel();
Optional<method*start>java.util.Optional<method*end><ServerTextChannel> severTextChannel = asServerTextChannel();
return !severTextChannel.isPresent() || severTextChannel.get().hasPermission(user, PermissionType<method*start>org.javacord.api.entity.permission.PermissionType<method*end>.ADMINISTRATOR) || severTextChannel.get().hasPermissions(user, PermissionType<method*start>org.javacord.api.entity.permission.PermissionType<method*end>.READ_MESSAGES, PermissionType<method*start>org.javacord.api.entity.permission.PermissionType<method*end>.SEND_MESSAGES);
}
|
conventional
|
default boolean canWrite(User<method*start>org.javacord.api.entity.user.User<method*end> user) {
Optional<method*start>java.util.Optional<method*end><PrivateChannel> privateChannel = asPrivateChannel();
if (privateChannel.isPresent()) {
return user.isYourself() || privateChannel.get().getRecipient() == user;
}
Optional<method*start>java.util.Optional<method*end><GroupChannel> groupChannel = asGroupChannel();
if (groupChannel.isPresent()) {
return user.isYourself() || groupChannel.get().getMembers().contains(user);
}
Optional<method*start>java.util.Optional<method*end><ServerTextChannel> severTextChannel = asServerTextChannel();
return !severTextChannel.isPresent() || severTextChannel.get().hasPermission(user, PermissionType<method*start>org.javacord.api.entity.permission.PermissionType<method*end>.ADMINISTRATOR) || severTextChannel.get().hasPermissions(user, PermissionType<method*start>org.javacord.api.entity.permission.PermissionType<method*end>.READ_MESSAGES, PermissionType<method*start>org.javacord.api.entity.permission.PermissionType<method*end>.SEND_MESSAGES);
}
|
@HiveWebsocketAuth
public void processUserUpdateCurrent(JsonObject<method*start>com.google.gson.JsonObject<method*end> request, WebSocketSession<method*start>org.springframework.web.socket.WebSocketSession<method*end> session) {
UserUpdate<method*start>com.devicehive.model.updates.UserUpdate<method*end> user = gson.fromJson<method*start>com.google.gson.Gson.fromJson<method*end>(request.get<method*start>com.google.gson.JsonObject.get<method*end>(USER<method*start>com.devicehive.configuration.Constants.USER<method*end>), UserUpdate.class);
logger.error<method*start>org.slf4j.Logger.error<method*end>(Messages.USER_REQUIRED<method*start>com.devicehive.configuration.Messages.USER_REQUIRED<method*end>);
throw new HiveException(Messages.USER_REQUIRED<method*start>com.devicehive.configuration.Messages.USER_REQUIRED<method*end>, BAD_REQUEST.getStatusCode<method*start>javax.ws.rs.core.Response.Status.getStatusCode<method*end>());
UserVO curUser = findCurrentUserFromAuthContext<method*start>com.devicehive.websockets.handlers.UserHandlers.findCurrentUserFromAuthContext<method*end>();
userService.updateUser<method*start>com.devicehive.service.UserService.updateUser<method*end>(curUser.getId<method*start>com.devicehive.vo.UserVO.getId<method*end>(), user, curUser);
clientHandler.sendMessage<method*start>com.devicehive.messages.handler.WebSocketClientHandler.sendMessage<method*end>(request, new WebSocketResponse(), session);
}
|
annotation
|
@HiveWebsocketAuth
@PreAuthorize<method*start>org.springframework.security.access.prepost.PreAuthorize<method*end>("isAuthenticated() and hasPermission(null, 'UPDATE_CURRENT_USER')")
public void processUserUpdateCurrent(JsonObject<method*start>com.google.gson.JsonObject<method*end> request, WebSocketSession<method*start>org.springframework.web.socket.WebSocketSession<method*end> session) {
UserUpdate<method*start>com.devicehive.model.updates.UserUpdate<method*end> user = gson.fromJson<method*start>com.google.gson.Gson.fromJson<method*end>(request.get<method*start>com.google.gson.JsonObject.get<method*end>(USER<method*start>com.devicehive.configuration.Constants.USER<method*end>), UserUpdate.class);
if (user == null) {
logger.error<method*start>org.slf4j.Logger.error<method*end>(Messages.USER_REQUIRED<method*start>com.devicehive.configuration.Messages.USER_REQUIRED<method*end>);
throw new HiveException(Messages.USER_REQUIRED<method*start>com.devicehive.configuration.Messages.USER_REQUIRED<method*end>, BAD_REQUEST.getStatusCode<method*start>javax.ws.rs.core.Response.Status.getStatusCode<method*end>());
}
UserVO curUser = findCurrentUserFromAuthContext<method*start>com.devicehive.websockets.handlers.UserHandlers.findCurrentUserFromAuthContext<method*end>();
userService.updateUser<method*start>com.devicehive.service.UserService.updateUser<method*end>(curUser.getId<method*start>com.devicehive.vo.UserVO.getId<method*end>(), user, curUser);
clientHandler.sendMessage<method*start>com.devicehive.messages.handler.WebSocketClientHandler.sendMessage<method*end>(request, new WebSocketResponse(), session);
}
|
@PutMapping<method*start>org.springframework.web.bind.annotation.PutMapping<method*end>("/{id}")
@Override<method*start>java.lang.Override<method*end>
public IntegrationDTO<method*start>com.qaprosoft.zafira.models.dto.integration.IntegrationDTO<method*end> update(@RequestBody<method*start>org.springframework.web.bind.annotation.RequestBody<method*end> IntegrationDTO integrationDTO, @PathVariable<method*start>org.springframework.web.bind.annotation.PathVariable<method*end>("id") Long<method*start>java.lang.Long<method*end> id) {
Integration<method*start>com.qaprosoft.zafira.models.entity.integration.Integration<method*end> integration = mapper.map<method*start>org.dozer.Mapper.map<method*end>(integrationDTO, Integration<method*start>com.qaprosoft.zafira.models.entity.integration.Integration<method*end>.class);
integration.setId<method*start>com.qaprosoft.zafira.models.entity.integration.Integration.setId<method*end>(id);
integration = integrationService.update<method*start>com.qaprosoft.zafira.service.integration.IntegrationService.update<method*end>(integration);
IntegrationDTO integrationUpdateResultDTO = mapper.map<method*start>org.dozer.Mapper.map<method*end>(integration, IntegrationDTO.class);
IntegrationInfo integrationInfo = integrationService.retrieveInfoByIntegration<method*start>com.qaprosoft.zafira.service.integration.IntegrationService.retrieveInfoByIntegration<method*end>(integration);
integrationUpdateResultDTO.setConnected<method*start>com.qaprosoft.zafira.models.dto.integration.IntegrationDTO.setConnected<method*end>(integrationInfo.isConnected<method*start>com.qaprosoft.zafira.models.entity.integration.IntegrationInfo.isConnected<method*end>());
return integrationUpdateResultDTO;
}
|
annotation
|
@PreAuthorize<method*start>org.springframework.security.access.prepost.PreAuthorize<method*end>("hasRole('ROLE_ADMIN') and hasPermission('MODIFY_INTEGRATIONS')")
@PutMapping<method*start>org.springframework.web.bind.annotation.PutMapping<method*end>("/{id}")
@Override<method*start>java.lang.Override<method*end>
public IntegrationDTO<method*start>com.qaprosoft.zafira.models.dto.integration.IntegrationDTO<method*end> update(@RequestBody<method*start>org.springframework.web.bind.annotation.RequestBody<method*end> IntegrationDTO integrationDTO, @PathVariable<method*start>org.springframework.web.bind.annotation.PathVariable<method*end>("id") Long<method*start>java.lang.Long<method*end> id) {
Integration<method*start>com.qaprosoft.zafira.models.entity.integration.Integration<method*end> integration = mapper.map<method*start>org.dozer.Mapper.map<method*end>(integrationDTO, Integration<method*start>com.qaprosoft.zafira.models.entity.integration.Integration<method*end>.class);
integration.setId<method*start>com.qaprosoft.zafira.models.entity.integration.Integration.setId<method*end>(id);
integration = integrationService.update<method*start>com.qaprosoft.zafira.service.integration.IntegrationService.update<method*end>(integration);
IntegrationDTO integrationUpdateResultDTO = mapper.map<method*start>org.dozer.Mapper.map<method*end>(integration, IntegrationDTO.class);
IntegrationInfo integrationInfo = integrationService.retrieveInfoByIntegration<method*start>com.qaprosoft.zafira.service.integration.IntegrationService.retrieveInfoByIntegration<method*end>(integration);
integrationUpdateResultDTO.setConnected<method*start>com.qaprosoft.zafira.models.dto.integration.IntegrationDTO.setConnected<method*end>(integrationInfo.isConnected<method*start>com.qaprosoft.zafira.models.entity.integration.IntegrationInfo.isConnected<method*end>());
return integrationUpdateResultDTO;
}
|
@Override
public void messageOnServerThread(final DirectPlaceMessage<method*start>com.minecolonies.coremod.network.messages.DirectPlaceMessage<method*end> message, final EntityPlayerMP<method*start>net.minecraft.entity.player.EntityPlayerMP<method*end> player) {
final World<method*start>net.minecraft.world.World<method*end> world = player.getServerWorld();
final IColony colony<method*start>com.minecolonies.coremod.colony.buildings.AbstractCitizenAssignable.colony<method*end> = IColonyManager.getInstance().getColonyByPosFromWorld(world, message.pos);
player.getServerWorld().setBlockState(message.pos, message.state);
InventoryUtils.reduceStackInItemHandler(new InvWrapper<method*start>net.minecraftforge.items.wrapper.InvWrapper<method*end>(player.inventory), message.stack);
message.state.getBlock().onBlockPlacedBy(world, message.pos, message.state, player, message.stack);
}
|
annotation
|
@Override
public void messageOnServerThread(final DirectPlaceMessage<method*start>com.minecolonies.coremod.network.messages.DirectPlaceMessage<method*end> message, final EntityPlayerMP<method*start>net.minecraft.entity.player.EntityPlayerMP<method*end> player) {
final World<method*start>net.minecraft.world.World<method*end> world = player.getServerWorld();
final IColony colony<method*start>com.minecolonies.coremod.colony.buildings.AbstractCitizenAssignable.colony<method*end> = IColonyManager.getInstance().getColonyByPosFromWorld(world, message.pos);
if (colony<method*start>com.minecolonies.coremod.colony.buildings.AbstractCitizenAssignable.colony<method*end> == null || colony<method*start>com.minecolonies.coremod.colony.buildings.AbstractCitizenAssignable.colony<method*end>.getPermissions().hasPermission(player, Action<method*start>com.minecolonies.api.colony.permissions.Action<method*end>.MANAGE_HUTS)) {
player.getServerWorld().setBlockState(message.pos, message.state);
InventoryUtils.reduceStackInItemHandler(new InvWrapper<method*start>net.minecraftforge.items.wrapper.InvWrapper<method*end>(player.inventory), message.stack);
message.state.getBlock().onBlockPlacedBy(world, message.pos, message.state, player, message.stack);
}
}
|
private void addResponses(DavResourceLocator<method*start>org.apache.jackrabbit.webdav.DavResourceLocator<method*end> locator) {
String<method*start>java.lang.String<method*end> repositoryPath = locator.getRepositoryPath<method*start>org.apache.jackrabbit.webdav.DavResourceLocator.getRepositoryPath<method*end>();
MultiStatusResponse<method*start>org.apache.jackrabbit.webdav.MultiStatusResponse<method*end> resp = new MultiStatusResponse<method*start>org.apache.jackrabbit.webdav.MultiStatusResponse<method*end>(locator.getHref<method*start>org.apache.jackrabbit.webdav.DavResourceLocator.getHref<method*end>(false), null);
List<method*start>java.util.List<method*end><Privilege<method*start>org.apache.jackrabbit.webdav.security.Privilege<method*end>> currentPrivs = new ArrayList<method*start>java.util.ArrayList<method*end><Privilege<method*start>org.apache.jackrabbit.webdav.security.Privilege<method*end>>();
for (Privilege<method*start>org.apache.jackrabbit.webdav.security.Privilege<method*end> priv : PRIVS) {
try {
currentPrivs.add<method*start>java.util.List.add<method*end>(priv);
}
} catch (RepositoryException<method*start>javax.jcr.RepositoryException<method*end> e) {
// ignore
log.debug<method*start>org.slf4j.Logger.debug<method*end>(e.toString<method*start>javax.jcr.RepositoryException.toString<method*end>());
}
}
resp.add<method*start>org.apache.jackrabbit.webdav.MultiStatusResponse.add<method*end>(new CurrentUserPrivilegeSetProperty<method*start>org.apache.jackrabbit.webdav.security.CurrentUserPrivilegeSetProperty<method*end>(currentPrivs.toArray<method*start>java.util.List.toArray<method*end>(new Privilege<method*start>org.apache.jackrabbit.webdav.security.Privilege<method*end>[currentPrivs.size<method*start>java.util.List.size<method*end>()])));
ms.addResponse<method*start>org.apache.jackrabbit.webdav.MultiStatus.addResponse<method*end>(resp);
}
|
conventional
|
private void addResponses(DavResourceLocator<method*start>org.apache.jackrabbit.webdav.DavResourceLocator<method*end> locator) {
String<method*start>java.lang.String<method*end> repositoryPath = locator.getRepositoryPath<method*start>org.apache.jackrabbit.webdav.DavResourceLocator.getRepositoryPath<method*end>();
MultiStatusResponse<method*start>org.apache.jackrabbit.webdav.MultiStatusResponse<method*end> resp = new MultiStatusResponse<method*start>org.apache.jackrabbit.webdav.MultiStatusResponse<method*end>(locator.getHref<method*start>org.apache.jackrabbit.webdav.DavResourceLocator.getHref<method*end>(false), null);
List<method*start>java.util.List<method*end><Privilege<method*start>org.apache.jackrabbit.webdav.security.Privilege<method*end>> currentPrivs = new ArrayList<method*start>java.util.ArrayList<method*end><Privilege<method*start>org.apache.jackrabbit.webdav.security.Privilege<method*end>>();
for (Privilege<method*start>org.apache.jackrabbit.webdav.security.Privilege<method*end> priv : PRIVS) {
try {
if (getRepositorySession<method*start>org.apache.jackrabbit.webdav.jcr.version.report.AbstractJcrReport.getRepositorySession<method*end>().hasPermission<method*start>javax.jcr.Session.hasPermission<method*end>(repositoryPath, priv.getName<method*start>org.apache.jackrabbit.webdav.security.Privilege.getName<method*end>())) {
currentPrivs.add<method*start>java.util.List.add<method*end>(priv);
}
} catch (RepositoryException<method*start>javax.jcr.RepositoryException<method*end> e) {
// ignore
log.debug<method*start>org.slf4j.Logger.debug<method*end>(e.toString<method*start>javax.jcr.RepositoryException.toString<method*end>());
}
}
resp.add<method*start>org.apache.jackrabbit.webdav.MultiStatusResponse.add<method*end>(new CurrentUserPrivilegeSetProperty<method*start>org.apache.jackrabbit.webdav.security.CurrentUserPrivilegeSetProperty<method*end>(currentPrivs.toArray<method*start>java.util.List.toArray<method*end>(new Privilege<method*start>org.apache.jackrabbit.webdav.security.Privilege<method*end>[currentPrivs.size<method*start>java.util.List.size<method*end>()])));
ms.addResponse<method*start>org.apache.jackrabbit.webdav.MultiStatus.addResponse<method*end>(resp);
}
|
@EventHandler(priority = EventPriority.HIGHEST)
public void checkDefuse(final PlayerInteractEvent event) {
if (!AntiGrief.Defuse.enabled())
return;
ItemStack hand = event.getPlayer().getItemInHand();
if (hand == null || hand.getType() != DEFUSE_ITEM)
return;
MatchPlayer clicker = this.mm.getPlayer(event.getPlayer());
if (clicker != null && clicker.isObserving() && clicker.getBukkit().hasPermission("pgm.defuse")) {
if (event.getAction() == Action.RIGHT_CLICK_AIR) {
this.obsTntDefuse(clicker.getBukkit(), event.getPlayer().getLocation());
} else if (event.getAction() == Action.RIGHT_CLICK_BLOCK) {
this.obsTntDefuse(clicker.getBukkit(), event.getClickedBlock().getLocation());
}
}
|
annotation
|
@EventHandler(priority = EventPriority<method*start>org.bukkit.event.EventPriority<method*end>.HIGHEST)
public void checkDefuse(final PlayerInteractEvent<method*start>org.bukkit.event.player.PlayerInteractEvent<method*end> event) {
if (!AntiGrief<method*start>tc.oc.pgm.antigrief.AntiGrief<method*end>.Defuse.enabled())
return;
ItemStack<method*start>org.bukkit.inventory.ItemStack<method*end> hand = event.getPlayer().getItemInHand();
if (hand == null || hand.getType() != DEFUSE_ITEM<method*start>tc.oc.pgm.antigrief.DefuseListener.DEFUSE_ITEM<method*end>)
return;
MatchPlayer<method*start>tc.oc.pgm.match.MatchPlayer<method*end> clicker = this.mm.getPlayer(event.getPlayer());
if (clicker != null && clicker.isObserving() && clicker.getBukkit().hasPermission("pgm.defuse")) {
if (event.getAction() == Action<method*start>org.bukkit.event.block.Action<method*end>.RIGHT_CLICK_AIR) {
this.obsTntDefuse(clicker.getBukkit(), event.getPlayer().getLocation());
} else if (event.getAction() == Action<method*start>org.bukkit.event.block.Action<method*end>.RIGHT_CLICK_BLOCK) {
this.obsTntDefuse(clicker.getBukkit(), event.getClickedBlock().getLocation());
}
}
}
|
public boolean requestObserve(MatchPlayer<method*start>tc.oc.pgm.match.MatchPlayer<method*end> leaving) {
if (cancelQueuedJoin<method*start>tc.oc.pgm.join.JoinMatchModule.cancelQueuedJoin<method*end>(leaving))
return true;
if (leaving.isObservingType()) {
leaving.sendWarning(new TranslatableComponent<method*start>net.md_5.bungee.api.chat.TranslatableComponent<method*end>("command.gameplay.leave.alreadyOnObservers"), false);
return false;
}
if (isRemoteJoin<method*start>tc.oc.pgm.join.JoinMatchModule.isRemoteJoin<method*end>()) {
ticketBooth<method*start>tc.oc.pgm.join.JoinMatchModule.ticketBooth<method*end>.leaveGame(leaving.getBukkit(), false);
}
if (config<method*start>tc.oc.pgm.join.JoinMatchModule.config<method*end>.commitPlayers() && leaving.isCommitted()) {
leaving.sendWarning(new TranslatableComponent<method*start>net.md_5.bungee.api.chat.TranslatableComponent<method*end>("command.gameplay.leave.leaveDenied"), false);
return false;
}
return observe<method*start>tc.oc.pgm.join.JoinMatchModule.observe<method*end>(leaving);
}
|
conventional
|
public boolean requestObserve(MatchPlayer<method*start>tc.oc.pgm.match.MatchPlayer<method*end> leaving) {
if (cancelQueuedJoin<method*start>tc.oc.pgm.join.JoinMatchModule.cancelQueuedJoin<method*end>(leaving))
return true;
if (leaving.isObservingType()) {
leaving.sendWarning(new TranslatableComponent<method*start>net.md_5.bungee.api.chat.TranslatableComponent<method*end>("command.gameplay.leave.alreadyOnObservers"), false);
return false;
}
if (isRemoteJoin<method*start>tc.oc.pgm.join.JoinMatchModule.isRemoteJoin<method*end>()) {
ticketBooth<method*start>tc.oc.pgm.join.JoinMatchModule.ticketBooth<method*end>.leaveGame(leaving.getBukkit(), false);
}
if (!leaving.getBukkit().hasPermission(JOIN_OBSERVERS_PERMISSION<method*start>tc.oc.pgm.join.JoinMatchModule.JOIN_OBSERVERS_PERMISSION<method*end>)) {
leaving.sendWarning(new TranslatableComponent<method*start>net.md_5.bungee.api.chat.TranslatableComponent<method*end>("command.gameplay.leave.leaveDenied"), false);
return false;
}
if (config<method*start>tc.oc.pgm.join.JoinMatchModule.config<method*end>.commitPlayers() && leaving.isCommitted()) {
leaving.sendWarning(new TranslatableComponent<method*start>net.md_5.bungee.api.chat.TranslatableComponent<method*end>("command.gameplay.leave.leaveDenied"), false);
return false;
}
return observe<method*start>tc.oc.pgm.join.JoinMatchModule.observe<method*end>(leaving);
}
|
public static boolean hasUnlocked(Player p, SlimefunItem sfItem, boolean message) {
if (sfItem.getResearch() == null)
return true;
else if (PlayerProfile.get(p).hasUnlocked(sfItem.getResearch()))
return true;
else {
if (message && !(sfItem instanceof VanillaItem))
SlimefunPlugin.getLocal().sendMessage(p, "messages.not-researched", true);
return false;
}
}
return false;
}
|
conventional
|
public static boolean hasUnlocked(Player<method*start>org.bukkit.entity.Player<method*end> p, SlimefunItem<method*start>me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SlimefunItem<method*end> sfItem, boolean message) {
if (isEnabled<method*start>me.mrCookieSlime.Slimefun.api.Slimefun.isEnabled<method*end>(p, sfItem, message) && hasPermission<method*start>me.mrCookieSlime.Slimefun.api.Slimefun.hasPermission<method*end>(p, sfItem, message)) {
if (sfItem.getResearch<method*start>me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SlimefunItem.getResearch<method*end>() == null)
return true;
else if (PlayerProfile.get<method*start>me.mrCookieSlime.Slimefun.api.PlayerProfile.get<method*end>(p).hasUnlocked<method*start>me.mrCookieSlime.Slimefun.api.PlayerProfile.hasUnlocked<method*end>(sfItem.getResearch<method*start>me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SlimefunItem.getResearch<method*end>()))
return true;
else {
if (message && !(sfItem instanceof VanillaItem))
SlimefunPlugin.getLocal<method*start>me.mrCookieSlime.Slimefun.SlimefunPlugin.getLocal<method*end>().sendMessage(p, "messages.not-researched", true);
return false;
}
}
return false;
}
|
@SuppressWarnings<method*start>java.lang.SuppressWarnings<method*end>("SimplifiableIfStatement")
public boolean canPreformSpecialAction(@Nonnull Command command, @Nonnull CommandMessage context, @Nonnull String action) {
VoiceChannel<method*start>net.dv8tion.jda.core.entities.VoiceChannel<method*end> channel = context.getMember<method*start>com.avairebot.commands.CommandMessage.getMember<method*end>().getVoiceState<method*start>net.fortuna.ical4j.model.parameter.Member.getVoiceState<method*end>().getChannel();
if (channel == null) {
return command.sendErrorMessage<method*start>com.avairebot.contracts.commands.Command.sendErrorMessage<method*end>(context, "errors.mustBeConnectedToVoice");
}
VoiceChannel<method*start>net.dv8tion.jda.core.entities.VoiceChannel<method*end> selfChannel = context.getGuild<method*start>com.avairebot.commands.CommandMessage.getGuild<method*end>().getSelfMember<method*start>com.github.princesslana.eriscasper.data.resource.Guild.getSelfMember<method*end>().getVoiceState().getChannel();
if (selfChannel == null || selfChannel.getIdLong<method*start>net.dv8tion.jda.core.entities.VoiceChannel.getIdLong<method*end>() != channel.getIdLong<method*start>net.dv8tion.jda.core.entities.VoiceChannel.getIdLong<method*end>()) {
return command.sendErrorMessage<method*start>com.avairebot.contracts.commands.Command.sendErrorMessage<method*end>(context, "errors.mustBeConnectedToSameChannel", action);
}
return true;
}
|
annotation
|
@SuppressWarnings<method*start>java.lang.SuppressWarnings<method*end>("SimplifiableIfStatement")
public boolean canPreformSpecialAction(@Nonnull Command command, @Nonnull CommandMessage context, @Nonnull String action) {
if (context.getMember<method*start>com.avairebot.commands.CommandMessage.getMember<method*end>().hasPermission<method*start>net.fortuna.ical4j.model.parameter.Member.hasPermission<method*end>(Permission.ADMINISTRATOR<method*start>net.dv8tion.jda.core.Permission.ADMINISTRATOR<method*end>)) {
return true;
}
VoiceChannel<method*start>net.dv8tion.jda.core.entities.VoiceChannel<method*end> channel = context.getMember<method*start>com.avairebot.commands.CommandMessage.getMember<method*end>().getVoiceState<method*start>net.fortuna.ical4j.model.parameter.Member.getVoiceState<method*end>().getChannel();
if (channel == null) {
return command.sendErrorMessage<method*start>com.avairebot.contracts.commands.Command.sendErrorMessage<method*end>(context, "errors.mustBeConnectedToVoice");
}
VoiceChannel<method*start>net.dv8tion.jda.core.entities.VoiceChannel<method*end> selfChannel = context.getGuild<method*start>com.avairebot.commands.CommandMessage.getGuild<method*end>().getSelfMember<method*start>com.github.princesslana.eriscasper.data.resource.Guild.getSelfMember<method*end>().getVoiceState().getChannel();
if (selfChannel == null || selfChannel.getIdLong<method*start>net.dv8tion.jda.core.entities.VoiceChannel.getIdLong<method*end>() != channel.getIdLong<method*start>net.dv8tion.jda.core.entities.VoiceChannel.getIdLong<method*end>()) {
return command.sendErrorMessage<method*start>com.avairebot.contracts.commands.Command.sendErrorMessage<method*end>(context, "errors.mustBeConnectedToSameChannel", action);
}
return true;
}
|
@RequestMapping<method*start>org.springframework.web.bind.annotation.RequestMapping<method*end>(method<method*start>org.springframework.web.bind.annotation.RequestMapping.method<method*end> = RequestMethod.GET<method*start>org.springframework.web.bind.annotation.RequestMethod.GET<method*end>)
@ResponseBody<method*start>org.springframework.web.bind.annotation.ResponseBody<method*end>
public StatChart<method*start>com.navercorp.pinpoint.web.vo.stat.chart.StatChart<method*end> getAgentStatChart(@RequestParam<method*start>org.springframework.web.bind.annotation.RequestParam<method*end>("applicationId") String<method*start>java.lang.String<method*end> applicationId, @RequestParam<method*start>org.springframework.web.bind.annotation.RequestParam<method*end>("from") long from, @RequestParam<method*start>org.springframework.web.bind.annotation.RequestParam<method*end>("to") long to) {
TimeWindowSlotCentricSampler<method*start>com.navercorp.pinpoint.web.util.TimeWindowSlotCentricSampler<method*end> sampler = new TimeWindowSlotCentricSampler<method*start>com.navercorp.pinpoint.web.util.TimeWindowSlotCentricSampler<method*end>();
TimeWindow<method*start>org.apache.flink.streaming.api.windowing.windows.TimeWindow<method*end> timeWindow = new TimeWindow<method*start>org.apache.flink.streaming.api.windowing.windows.TimeWindow<method*end>(new Range<method*start>com.navercorp.pinpoint.web.vo.Range<method*end>(from, to), sampler);
try {
return this.applicationStatChartService.selectApplicationChart<method*start>com.navercorp.pinpoint.web.service.stat.ApplicationStatChartService.selectApplicationChart<method*end>(applicationId, timeWindow);
} catch (Exception<method*start>java.lang.Exception<method*end> e) {
logger.error<method*start>org.slf4j.Logger.error<method*end>("error", e);
throw e;
}
}
|
annotation
|
@PreAuthorize<method*start>org.springframework.security.access.prepost.PreAuthorize<method*end>("hasPermission(#applicationId, 'application', 'inspector')")
@RequestMapping<method*start>org.springframework.web.bind.annotation.RequestMapping<method*end>(method<method*start>org.springframework.web.bind.annotation.RequestMapping.method<method*end> = RequestMethod.GET<method*start>org.springframework.web.bind.annotation.RequestMethod.GET<method*end>)
@ResponseBody<method*start>org.springframework.web.bind.annotation.ResponseBody<method*end>
public StatChart<method*start>com.navercorp.pinpoint.web.vo.stat.chart.StatChart<method*end> getAgentStatChart(@RequestParam<method*start>org.springframework.web.bind.annotation.RequestParam<method*end>("applicationId") String<method*start>java.lang.String<method*end> applicationId, @RequestParam<method*start>org.springframework.web.bind.annotation.RequestParam<method*end>("from") long from, @RequestParam<method*start>org.springframework.web.bind.annotation.RequestParam<method*end>("to") long to) {
TimeWindowSlotCentricSampler<method*start>com.navercorp.pinpoint.web.util.TimeWindowSlotCentricSampler<method*end> sampler = new TimeWindowSlotCentricSampler<method*start>com.navercorp.pinpoint.web.util.TimeWindowSlotCentricSampler<method*end>();
TimeWindow<method*start>org.apache.flink.streaming.api.windowing.windows.TimeWindow<method*end> timeWindow = new TimeWindow<method*start>org.apache.flink.streaming.api.windowing.windows.TimeWindow<method*end>(new Range<method*start>com.navercorp.pinpoint.web.vo.Range<method*end>(from, to), sampler);
try {
return this.applicationStatChartService.selectApplicationChart<method*start>com.navercorp.pinpoint.web.service.stat.ApplicationStatChartService.selectApplicationChart<method*end>(applicationId, timeWindow);
} catch (Exception<method*start>java.lang.Exception<method*end> e) {
logger.error<method*start>org.slf4j.Logger.error<method*end>("error", e);
throw e;
}
}
|
@Override
public void messageOnServerThread(final ComposterRetrievalMessagecom.minecolonies.coremod.network.messages.ComposterRetrievalMessage message, final EntityPlayerMPnet.minecraft.entity.player.EntityPlayerMP player) {
final IColonycom.minecolonies.api.colony.IColony colony = IColonyManagercom.minecolonies.api.colony.IColonyManager.getInstance().getColonyByDimension(message.colonyId, message.dimension);
if (colonycom.minecolonies.coremod.colony.buildings.AbstractCitizenAssignable.colony != null) {
return;
}
@Nullable final IBuildingWorker building = colonycom.minecolonies.coremod.colony.buildings.AbstractCitizenAssignable.colony.getBuildingManager().getBuilding(message.buildingId, AbstractBuildingWorkercom.minecolonies.coremod.colony.buildings.AbstractBuildingWorker.class);
if (building instanceof BuildingComposter) {
((BuildingComposter) building).setShouldRetrieveDirtFromCompostBin(message.retrieveDirt);
}
}
}
|
annotation
|
@Override
public void messageOnServerThread(final ComposterRetrievalMessage<method*start>com.minecolonies.coremod.network.messages.ComposterRetrievalMessage<method*end> message, final EntityPlayerMP<method*start>net.minecraft.entity.player.EntityPlayerMP<method*end> player) {
final IColony<method*start>com.minecolonies.api.colony.IColony<method*end> colony = IColonyManager<method*start>com.minecolonies.api.colony.IColonyManager<method*end>.getInstance().getColonyByDimension(message.colonyId, message.dimension);
if (colony<method*start>com.minecolonies.coremod.colony.buildings.AbstractCitizenAssignable.colony<method*end> != null) {
// Verify player has permission to change this hut's settings
if (!colony<method*start>com.minecolonies.coremod.colony.buildings.AbstractCitizenAssignable.colony<method*end>.getPermissions().hasPermission(player, Action<method*start>com.minecolonies.api.colony.permissions.Action<method*end>.MANAGE_HUTS)) {
return;
}
@Nullable final IBuildingWorker building = colony<method*start>com.minecolonies.coremod.colony.buildings.AbstractCitizenAssignable.colony<method*end>.getBuildingManager().getBuilding(message.buildingId, AbstractBuildingWorker<method*start>com.minecolonies.coremod.colony.buildings.AbstractBuildingWorker<method*end>.class);
if (building instanceof BuildingComposter) {
((BuildingComposter) building).setShouldRetrieveDirtFromCompostBin(message.retrieveDirt);
}
}
}
|
@Nonnull<method*start>javax.annotation.Nonnull<method*end>
@Override<method*start>java.lang.Override<method*end>
public List<method*start>java.util.List<method*end><CompletableFuture<method*start>java.util.concurrent.CompletableFuture<method*end><Void<method*start>java.lang.Void<method*end>>> purgeMessages(@Nonnull<method*start>javax.annotation.Nonnull<method*end> List<? extends Message<method*start>net.dv8tion.jda.api.entities.Message<method*end>> messages) {
if (messages == null || messages.isEmpty<method*start>java.util.List.isEmpty<method*end>())
return Collections.emptyList<method*start>java.util.Collections.emptyList<method*end>();
for (Message<method*start>net.dv8tion.jda.api.entities.Message<method*end> m : messages) {
if (m.getAuthor<method*start>net.dv8tion.jda.api.entities.Message.getAuthor<method*end>().equals<method*start>net.dv8tion.jda.api.entities.User.equals<method*end>(getJDA<method*start>net.dv8tion.jda.internal.entities.AbstractChannelImpl.getJDA<method*end>().getSelfUser<method*start>net.dv8tion.jda.api.JDA.getSelfUser<method*end>()))
continue;
throw new InsufficientPermissionException(this, Permission.MESSAGE_MANAGE<method*start>net.dv8tion.jda.api.Permission.MESSAGE_MANAGE<method*end>, "Cannot delete messages of other users");
}
}
return TextChannel<method*start>net.dv8tion.jda.api.entities.TextChannel<method*end>.super.purgeMessages<method*start>net.dv8tion.jda.api.entities.TextChannel.super.purgeMessages<method*end>(messages);
}
|
annotation
|
@Nonnull<method*start>javax.annotation.Nonnull<method*end>
@Override<method*start>java.lang.Override<method*end>
public List<method*start>java.util.List<method*end><CompletableFuture<method*start>java.util.concurrent.CompletableFuture<method*end><Void<method*start>java.lang.Void<method*end>>> purgeMessages(@Nonnull<method*start>javax.annotation.Nonnull<method*end> List<? extends Message<method*start>net.dv8tion.jda.api.entities.Message<method*end>> messages) {
if (messages == null || messages.isEmpty<method*start>java.util.List.isEmpty<method*end>())
return Collections.emptyList<method*start>java.util.Collections.emptyList<method*end>();
boolean hasPerms = getGuild<method*start>net.dv8tion.jda.internal.entities.AbstractChannelImpl.getGuild<method*end>().getSelfMember<method*start>net.dv8tion.jda.internal.entities.GuildImpl.getSelfMember<method*end>().hasPermission<method*start>net.dv8tion.jda.api.entities.Member.hasPermission<method*end>(this, Permission.MESSAGE_MANAGE<method*start>net.dv8tion.jda.api.Permission.MESSAGE_MANAGE<method*end>);
if (!hasPerms) {
for (Message<method*start>net.dv8tion.jda.api.entities.Message<method*end> m : messages) {
if (m.getAuthor<method*start>net.dv8tion.jda.api.entities.Message.getAuthor<method*end>().equals<method*start>net.dv8tion.jda.api.entities.User.equals<method*end>(getJDA<method*start>net.dv8tion.jda.internal.entities.AbstractChannelImpl.getJDA<method*end>().getSelfUser<method*start>net.dv8tion.jda.api.JDA.getSelfUser<method*end>()))
continue;
throw new InsufficientPermissionException(this, Permission.MESSAGE_MANAGE<method*start>net.dv8tion.jda.api.Permission.MESSAGE_MANAGE<method*end>, "Cannot delete messages of other users");
}
}
return TextChannel<method*start>net.dv8tion.jda.api.entities.TextChannel<method*end>.super.purgeMessages<method*start>net.dv8tion.jda.api.entities.TextChannel.super.purgeMessages<method*end>(messages);
}
|
@Override
public BitstreamRest<method*start>org.dspace.app.rest.model.BitstreamRest<method*end> findOne(Context<method*start>org.dspace.core.Context<method*end> context, UUID<method*start>java.util.UUID<method*end> id) {
Bitstream<method*start>org.dspace.content.Bitstream<method*end> bit = null;
try {
bit = bs.find<method*start>org.dspace.content.service.BitstreamService.find<method*end>(context, id);
} catch (SQLException<method*start>java.sql.SQLException<method*end> e) {
throw new RuntimeException<method*start>java.lang.RuntimeException<method*end>(e.getMessage<method*start>java.sql.SQLException.getMessage<method*end>(), e);
}
if (bit == null) {
return null;
}
try {
if (bit.isDeleted<method*start>org.dspace.content.Bitstream.isDeleted<method*end>() == true) {
throw new ResourceNotFoundException<method*start>org.springframework.data.rest.webmvc.ResourceNotFoundException<method*end>();
}
} catch (SQLException<method*start>java.sql.SQLException<method*end> e) {
throw new RuntimeException<method*start>java.lang.RuntimeException<method*end>(e.getMessage<method*start>java.sql.SQLException.getMessage<method*end>(), e);
}
return converter.toRest<method*start>org.dspace.app.rest.converter.ConverterService.toRest<method*end>(bit, utils.obtainProjection<method*start>org.dspace.app.rest.utils.Utils.obtainProjection<method*end>());
}
|
annotation
|
@Override<method*start>java.lang.Override<method*end>
@PreAuthorize<method*start>org.springframework.security.access.prepost.PreAuthorize<method*end>("hasPermission(#id, 'BITSTREAM', 'READ')")
public BitstreamRest<method*start>org.dspace.app.rest.model.BitstreamRest<method*end> findOne(Context<method*start>org.dspace.core.Context<method*end> context, UUID<method*start>java.util.UUID<method*end> id) {
Bitstream<method*start>org.dspace.content.Bitstream<method*end> bit = null;
try {
bit = bs.find<method*start>org.dspace.content.service.BitstreamService.find<method*end>(context, id);
} catch (SQLException<method*start>java.sql.SQLException<method*end> e) {
throw new RuntimeException<method*start>java.lang.RuntimeException<method*end>(e.getMessage<method*start>java.sql.SQLException.getMessage<method*end>(), e);
}
if (bit == null) {
return null;
}
try {
if (bit.isDeleted<method*start>org.dspace.content.Bitstream.isDeleted<method*end>() == true) {
throw new ResourceNotFoundException<method*start>org.springframework.data.rest.webmvc.ResourceNotFoundException<method*end>();
}
} catch (SQLException<method*start>java.sql.SQLException<method*end> e) {
throw new RuntimeException<method*start>java.lang.RuntimeException<method*end>(e.getMessage<method*start>java.sql.SQLException.getMessage<method*end>(), e);
}
return converter.toRest<method*start>org.dspace.app.rest.converter.ConverterService.toRest<method*end>(bit, utils.obtainProjection<method*start>org.dspace.app.rest.utils.Utils.obtainProjection<method*end>());
}
|
public ApplicationAgentsList getAgentList(@RequestParam("application") String applicationName, @RequestParam("timestamp") long timestamp) {
ApplicationAgentsList.Filter runningContainerFilter = agentInfo -> {
if (!agentInfo.isContainer()) {
return ApplicationAgentsList.Filter.ACCEPT;
}
AgentStatus agentStatus = agentInfo.getStatus();
if (agentStatus == null) {
return ApplicationAgentsList.Filter.REJECT;
}
if (agentStatus.getState() == AgentLifeCycleState.RUNNING) {
return ApplicationAgentsList.Filter.ACCEPT;
}
return ApplicationAgentsList.Filter.REJECT;
};
return this.agentInfoService.getApplicationAgentsList(ApplicationAgentsList.GroupBy.HOST_NAME, runningContainerFilter, applicationName, timestamp);
}
|
annotation
|
@PreAuthorize<method*start>org.springframework.security.access.prepost.PreAuthorize<method*end>("hasPermission(#applicationName, 'application', 'inspector')")
@RequestMapping<method*start>org.springframework.web.bind.annotation.RequestMapping<method*end>(value<method*start>org.springframework.boot.autoconfigure.condition.ConditionalOnProperty.value<method*end> = "/getAgentList", method<method*start>org.springframework.web.bind.annotation.RequestMapping.method<method*end> = RequestMethod.GET<method*start>org.springframework.web.bind.annotation.RequestMethod.GET<method*end>, params<method*start>org.springframework.web.bind.annotation.RequestMapping.params<method*end> = { "application", "timestamp" })
@ResponseBody<method*start>org.springframework.web.bind.annotation.ResponseBody<method*end>
public ApplicationAgentsList<method*start>com.navercorp.pinpoint.web.vo.ApplicationAgentsList<method*end> getAgentList(@RequestParam<method*start>org.springframework.web.bind.annotation.RequestParam<method*end>("application") String<method*start>java.lang.String<method*end> applicationName, @RequestParam<method*start>org.springframework.web.bind.annotation.RequestParam<method*end>("timestamp") long timestamp) {
ApplicationAgentsList.Filter<method*start>com.navercorp.pinpoint.web.vo.ApplicationAgentsList.Filter<method*end> runningContainerFilter = agentInfo -> {
if (!agentInfo.isContainer<method*start>agentInfo.isContainer<method*end>()) {
return ApplicationAgentsList.Filter.ACCEPT<method*start>com.navercorp.pinpoint.web.vo.ApplicationAgentsList.Filter.ACCEPT<method*end>;
}
AgentStatus<method*start>com.navercorp.pinpoint.profiler.AgentStatus<method*end> agentStatus = agentInfo.getStatus<method*start>agentInfo.getStatus<method*end>();
if (agentStatus == null) {
return ApplicationAgentsList.Filter.REJECT<method*start>com.navercorp.pinpoint.web.vo.ApplicationAgentsList.Filter.REJECT<method*end>;
}
if (agentStatus.getState<method*start>com.navercorp.pinpoint.web.vo.AgentStatus.getState<method*end>() == AgentLifeCycleState.RUNNING<method*start>com.navercorp.pinpoint.common.server.util.AgentLifeCycleState.RUNNING<method*end>) {
return ApplicationAgentsList.Filter.ACCEPT<method*start>com.navercorp.pinpoint.web.vo.ApplicationAgentsList.Filter.ACCEPT<method*end>;
}
return ApplicationAgentsList.Filter.REJECT<method*start>com.navercorp.pinpoint.web.vo.ApplicationAgentsList.Filter.REJECT<method*end>;
};
return this.agentInfoService.getApplicationAgentsList<method*start>com.navercorp.pinpoint.web.service.AgentInfoService.getApplicationAgentsList<method*end>(ApplicationAgentsList.GroupBy.HOST_NAME<method*start>com.navercorp.pinpoint.web.vo.ApplicationAgentsList.GroupBy.HOST_NAME<method*end>, runningContainerFilter, applicationName, timestamp);
}
|
@GetMapping<method*start>org.springframework.web.bind.annotation.GetMapping<method*end>()
@Override<method*start>java.lang.Override<method*end>
public List<method*start>java.util.List<method*end><IntegrationDTO<method*start>com.qaprosoft.zafira.models.dto.integration.IntegrationDTO<method*end>> getAll(@RequestParam<method*start>org.springframework.web.bind.annotation.RequestParam<method*end>(name<method*start>org.springframework.web.bind.annotation.RequestParam.name<method*end> = "groupId", required<method*start>org.springframework.web.bind.annotation.RequestParam.required<method*end> = false) Long<method*start>java.lang.Long<method*end> groupId, @RequestParam<method*start>org.springframework.web.bind.annotation.RequestParam<method*end>(name<method*start>org.springframework.web.bind.annotation.RequestParam.name<method*end> = "groupName", required<method*start>org.springframework.web.bind.annotation.RequestParam.required<method*end> = false) String<method*start>java.lang.String<method*end> groupName) {
List<method*start>java.util.List<method*end><Integration<method*start>com.qaprosoft.zafira.models.entity.integration.Integration<method*end>> integrations;
if (groupId != null) {
integrations = integrationService.retrieveIntegrationsByGroupId<method*start>com.qaprosoft.zafira.service.integration.IntegrationService.retrieveIntegrationsByGroupId<method*end>(groupId);
} else if (groupName != null) {
integrations = integrationService.retrieveIntegrationsByGroupName<method*start>com.qaprosoft.zafira.service.integration.IntegrationService.retrieveIntegrationsByGroupName<method*end>(groupName);
} else {
integrations = integrationService.retrieveAll<method*start>com.qaprosoft.zafira.service.integration.IntegrationService.retrieveAll<method*end>();
}
return integrations.stream<method*start>java.util.List.stream<method*end>().map<method*start>java.util.stream.Stream.map<method*end>(integration -> mapper.map<method*start>org.dozer.Mapper.map<method*end>(integration, IntegrationDTO<method*start>com.qaprosoft.zafira.models.dto.integration.IntegrationDTO<method*end>.class)).collect<method*start>java.util.stream.Stream.collect<method*end>(Collectors.toList<method*start>java.util.stream.Collectors.toList<method*end>());
}
|
annotation
|
@PreAuthorize<method*start>org.springframework.security.access.prepost.PreAuthorize<method*end>("hasPermission('VIEW_INTEGRATIONS') or isAuthenticated()")
@GetMapping<method*start>org.springframework.web.bind.annotation.GetMapping<method*end>()
@Override<method*start>java.lang.Override<method*end>
public List<method*start>java.util.List<method*end><IntegrationDTO<method*start>com.qaprosoft.zafira.models.dto.integration.IntegrationDTO<method*end>> getAll(@RequestParam<method*start>org.springframework.web.bind.annotation.RequestParam<method*end>(name<method*start>org.springframework.web.bind.annotation.RequestParam.name<method*end> = "groupId", required<method*start>org.springframework.web.bind.annotation.RequestParam.required<method*end> = false) Long<method*start>java.lang.Long<method*end> groupId, @RequestParam<method*start>org.springframework.web.bind.annotation.RequestParam<method*end>(name<method*start>org.springframework.web.bind.annotation.RequestParam.name<method*end> = "groupName", required<method*start>org.springframework.web.bind.annotation.RequestParam.required<method*end> = false) String<method*start>java.lang.String<method*end> groupName) {
List<method*start>java.util.List<method*end><Integration<method*start>com.qaprosoft.zafira.models.entity.integration.Integration<method*end>> integrations;
if (groupId != null) {
integrations = integrationService.retrieveIntegrationsByGroupId<method*start>com.qaprosoft.zafira.service.integration.IntegrationService.retrieveIntegrationsByGroupId<method*end>(groupId);
} else if (groupName != null) {
integrations = integrationService.retrieveIntegrationsByGroupName<method*start>com.qaprosoft.zafira.service.integration.IntegrationService.retrieveIntegrationsByGroupName<method*end>(groupName);
} else {
integrations = integrationService.retrieveAll<method*start>com.qaprosoft.zafira.service.integration.IntegrationService.retrieveAll<method*end>();
}
return integrations.stream<method*start>java.util.List.stream<method*end>().map<method*start>java.util.stream.Stream.map<method*end>(integration -> mapper.map<method*start>org.dozer.Mapper.map<method*end>(integration, IntegrationDTO<method*start>com.qaprosoft.zafira.models.dto.integration.IntegrationDTO<method*end>.class)).collect<method*start>java.util.stream.Stream.collect<method*end>(Collectors.toList<method*start>java.util.stream.Collectors.toList<method*end>());
}
|
@HiveWebsocketAuth
public void processNetworkUpdate(Long networkId, JsonObject request, WebSocketSession session) {
NetworkUpdate networkToUpdate = gson.fromJson(request.get(NETWORK), NetworkUpdate.class);
logger.debug("Network update requested. Id : {}", networkId);
if (networkId == null) {
logger.error(Messages.NETWORK_ID_REQUIRED);
throw new HiveException(Messages.NETWORK_ID_REQUIRED, BAD_REQUEST.getStatusCode());
}
networkService.update(networkId, networkToUpdate);
logger.debug("Network has been updated successfully. Id : {}", networkId);
webSocketClientHandler.sendMessage(request, new WebSocketResponse(), session);
}
|
annotation
|
@HiveWebsocketAuth
@PreAuthorize<method*start>org.springframework.security.access.prepost.PreAuthorize<method*end>("isAuthenticated() and hasPermission(#networkId, 'MANAGE_NETWORK')")
public void processNetworkUpdate(Long<method*start>java.lang.Long<method*end> networkId, JsonObject<method*start>com.google.gson.JsonObject<method*end> request, WebSocketSession<method*start>org.springframework.web.socket.WebSocketSession<method*end> session) {
NetworkUpdate<method*start>com.devicehive.model.updates.NetworkUpdate<method*end> networkToUpdate = gson.fromJson<method*start>com.google.gson.Gson.fromJson<method*end>(request.get<method*start>com.google.gson.JsonObject.get<method*end>(NETWORK<method*start>com.devicehive.configuration.Constants.NETWORK<method*end>), NetworkUpdate.class);
logger.debug<method*start>org.slf4j.Logger.debug<method*end>("Network update requested. Id : {}", networkId);
if (networkId == null) {
logger.error<method*start>org.slf4j.Logger.error<method*end>(Messages.NETWORK_ID_REQUIRED<method*start>com.devicehive.configuration.Messages.NETWORK_ID_REQUIRED<method*end>);
throw new HiveException(Messages.NETWORK_ID_REQUIRED<method*start>com.devicehive.configuration.Messages.NETWORK_ID_REQUIRED<method*end>, BAD_REQUEST.getStatusCode<method*start>javax.ws.rs.core.Response.Status.getStatusCode<method*end>());
}
networkService.update<method*start>com.devicehive.service.NetworkService.update<method*end>(networkId, networkToUpdate);
logger.debug<method*start>org.slf4j.Logger.debug<method*end>("Network has been updated successfully. Id : {}", networkId);
webSocketClientHandler.sendMessage<method*start>com.devicehive.messages.handler.WebSocketClientHandler.sendMessage<method*end>(request, new WebSocketResponse(), session);
}
|
@RequestMapping<method*start>org.springframework.web.bind.annotation.RequestMapping<method*end>(value<method*start>org.springframework.boot.autoconfigure.condition.ConditionalOnProperty.value<method*end> = "/member", method<method*start>org.springframework.web.bind.annotation.RequestMapping.method<method*end> = RequestMethod.POST<method*start>org.springframework.web.bind.annotation.RequestMethod.POST<method*end>)
@ResponseBody<method*start>org.springframework.web.bind.annotation.ResponseBody<method*end>
public Map<method*start>java.util.Map<method*end><String<method*start>java.lang.String<method*end>, String<method*start>java.lang.String<method*end>> insertUserGroupMember(@RequestBody<method*start>org.springframework.web.bind.annotation.RequestBody<method*end> UserGroupMemberParam userGroupMember) {
if (StringUtils.isEmpty<method*start>org.springframework.util.StringUtils.isEmpty<method*end>(userGroupMember.getMemberId<method*start>com.navercorp.pinpoint.web.vo.UserGroupMember.getMemberId<method*end>()) || StringUtils.isEmpty<method*start>org.springframework.util.StringUtils.isEmpty<method*end>(userGroupMember.getUserGroupId<method*start>com.navercorp.pinpoint.web.vo.UserGroupMember.getUserGroupId<method*end>())) {
return createErrorMessage<method*start>com.navercorp.pinpoint.web.controller.UserGroupController.createErrorMessage<method*end>("500", "there is not userGroupId or memberId in params to insert user group member");
}
userGroupService.insertMember<method*start>com.navercorp.pinpoint.web.service.UserGroupService.insertMember<method*end>(userGroupMember);
Map<method*start>java.util.Map<method*end><String<method*start>java.lang.String<method*end>, String<method*start>java.lang.String<method*end>> result = new HashMap<method*start>java.util.HashMap<method*end><>();
result.put<method*start>java.util.Map.put<method*end>("result", "SUCCESS");
return result;
}
|
annotation
|
@PreAuthorize<method*start>org.springframework.security.access.prepost.PreAuthorize<method*end>("hasPermission(#userGroupMember.getUserGroupId(), null, T(com.navercorp.pinpoint.web.controller.UserGroupController).EDIT_GROUP_ONLY_GROUPMEMBER)")
@RequestMapping<method*start>org.springframework.web.bind.annotation.RequestMapping<method*end>(value<method*start>org.springframework.boot.autoconfigure.condition.ConditionalOnProperty.value<method*end> = "/member", method<method*start>org.springframework.web.bind.annotation.RequestMapping.method<method*end> = RequestMethod.POST<method*start>org.springframework.web.bind.annotation.RequestMethod.POST<method*end>)
@ResponseBody<method*start>org.springframework.web.bind.annotation.ResponseBody<method*end>
public Map<method*start>java.util.Map<method*end><String<method*start>java.lang.String<method*end>, String<method*start>java.lang.String<method*end>> insertUserGroupMember(@RequestBody<method*start>org.springframework.web.bind.annotation.RequestBody<method*end> UserGroupMemberParam userGroupMember) {
if (StringUtils.isEmpty<method*start>org.springframework.util.StringUtils.isEmpty<method*end>(userGroupMember.getMemberId<method*start>com.navercorp.pinpoint.web.vo.UserGroupMember.getMemberId<method*end>()) || StringUtils.isEmpty<method*start>org.springframework.util.StringUtils.isEmpty<method*end>(userGroupMember.getUserGroupId<method*start>com.navercorp.pinpoint.web.vo.UserGroupMember.getUserGroupId<method*end>())) {
return createErrorMessage<method*start>com.navercorp.pinpoint.web.controller.UserGroupController.createErrorMessage<method*end>("500", "there is not userGroupId or memberId in params to insert user group member");
}
userGroupService.insertMember<method*start>com.navercorp.pinpoint.web.service.UserGroupService.insertMember<method*end>(userGroupMember);
Map<method*start>java.util.Map<method*end><String<method*start>java.lang.String<method*end>, String<method*start>java.lang.String<method*end>> result = new HashMap<method*start>java.util.HashMap<method*end><>();
result.put<method*start>java.util.Map.put<method*end>("result", "SUCCESS");
return result;
}
|
@RequestMapping<method*start>org.springframework.web.bind.annotation.RequestMapping<method*end>(method<method*start>org.springframework.web.bind.annotation.RequestMapping.method<method*end> = RequestMethod.GET<method*start>org.springframework.web.bind.annotation.RequestMethod.GET<method*end>)
public ItemResource<method*start>org.dspace.app.rest.model.hateoas.ItemResource<method*end> getTemplateItem(HttpServletRequest<method*start>javax.servlet.http.HttpServletRequest<method*end> request, @PathVariable<method*start>org.springframework.web.bind.annotation.PathVariable<method*end> UUID uuid) {
Context<method*start>org.dspace.core.Context<method*end> context = ContextUtil.obtainContext<method*start>org.dspace.app.rest.utils.ContextUtil.obtainContext<method*end>(request);
ItemRest<method*start>org.dspace.app.rest.model.ItemRest<method*end> templateItem = itemRestRepository.findOne<method*start>org.dspace.app.rest.repository.ItemRestRepository.findOne<method*end>(context, uuid);
if (templateItem == null) {
throw new ResourceNotFoundException<method*start>org.springframework.data.rest.webmvc.ResourceNotFoundException<method*end>("Item with id: " + uuid + " not found");
}
if (templateItem.getTemplateItemOf<method*start>org.dspace.app.rest.model.ItemRest.getTemplateItemOf<method*end>() == null) {
throw new ResourceNotFoundException<method*start>org.springframework.data.rest.webmvc.ResourceNotFoundException<method*end>("The item with id " + uuid + " is not a template item");
}
return new ItemResource<method*start>org.dspace.app.rest.model.hateoas.ItemResource<method*end>(templateItem, utils);
}
|
annotation
|
@PreAuthorize<method*start>org.springframework.security.access.prepost.PreAuthorize<method*end>("hasPermission(#uuid, 'COLLECTION', 'READ')")
@RequestMapping<method*start>org.springframework.web.bind.annotation.RequestMapping<method*end>(method<method*start>org.springframework.web.bind.annotation.RequestMapping.method<method*end> = RequestMethod.GET<method*start>org.springframework.web.bind.annotation.RequestMethod.GET<method*end>)
public ItemResource<method*start>org.dspace.app.rest.model.hateoas.ItemResource<method*end> getTemplateItem(HttpServletRequest<method*start>javax.servlet.http.HttpServletRequest<method*end> request, @PathVariable<method*start>org.springframework.web.bind.annotation.PathVariable<method*end> UUID uuid) {
Context<method*start>org.dspace.core.Context<method*end> context = ContextUtil.obtainContext<method*start>org.dspace.app.rest.utils.ContextUtil.obtainContext<method*end>(request);
ItemRest<method*start>org.dspace.app.rest.model.ItemRest<method*end> templateItem = itemRestRepository.findOne<method*start>org.dspace.app.rest.repository.ItemRestRepository.findOne<method*end>(context, uuid);
if (templateItem == null) {
throw new ResourceNotFoundException<method*start>org.springframework.data.rest.webmvc.ResourceNotFoundException<method*end>("Item with id: " + uuid + " not found");
}
if (templateItem.getTemplateItemOf<method*start>org.dspace.app.rest.model.ItemRest.getTemplateItemOf<method*end>() == null) {
throw new ResourceNotFoundException<method*start>org.springframework.data.rest.webmvc.ResourceNotFoundException<method*end>("The item with id " + uuid + " is not a template item");
}
return new ItemResource<method*start>org.dspace.app.rest.model.hateoas.ItemResource<method*end>(templateItem, utils);
}
|
@RequestMapping<method*start>org.springframework.web.bind.annotation.RequestMapping<method*end>(method<method*start>org.springframework.web.bind.annotation.RequestMapping.method<method*end> = RequestMethod.DELETE<method*start>org.springframework.web.bind.annotation.RequestMethod.DELETE<method*end>)
@ResponseBody<method*start>org.springframework.web.bind.annotation.ResponseBody<method*end>
public Map<method*start>java.util.Map<method*end><String<method*start>java.lang.String<method*end>, String<method*start>java.lang.String<method*end>> deleteRule(@RequestBody<method*start>org.springframework.web.bind.annotation.RequestBody<method*end> Rule rule) {
if (StringUtils.isEmpty<method*start>org.springframework.util.StringUtils.isEmpty<method*end>(rule.getRuleId<method*start>com.navercorp.pinpoint.web.alarm.vo.Rule.getRuleId<method*end>())) {
Map<method*start>java.util.Map<method*end><String<method*start>java.lang.String<method*end>, String<method*start>java.lang.String<method*end>> result = new HashMap<method*start>java.util.HashMap<method*end><>();
result.put<method*start>java.util.Map.put<method*end>("errorCode", "500");
result.put<method*start>java.util.Map.put<method*end>("errorMessage", "there is not ruleId to delete alarm rule");
return result;
}
alarmService.deleteRule<method*start>com.navercorp.pinpoint.web.service.AlarmService.deleteRule<method*end>(rule);
Map<method*start>java.util.Map<method*end><String<method*start>java.lang.String<method*end>, String<method*start>java.lang.String<method*end>> result = new HashMap<method*start>java.util.HashMap<method*end><>();
result.put<method*start>java.util.Map.put<method*end>("result", "SUCCESS");
return result;
}
|
annotation
|
@PreAuthorize<method*start>org.springframework.security.access.prepost.PreAuthorize<method*end>("hasPermission(#rule.getApplicationId(), null, T(com.navercorp.pinpoint.web.controller.AlarmController).EDIT_ALARM_ONLY_MANAGER)")
@RequestMapping<method*start>org.springframework.web.bind.annotation.RequestMapping<method*end>(method<method*start>org.springframework.web.bind.annotation.RequestMapping.method<method*end> = RequestMethod.DELETE<method*start>org.springframework.web.bind.annotation.RequestMethod.DELETE<method*end>)
@ResponseBody<method*start>org.springframework.web.bind.annotation.ResponseBody<method*end>
public Map<method*start>java.util.Map<method*end><String<method*start>java.lang.String<method*end>, String<method*start>java.lang.String<method*end>> deleteRule(@RequestBody<method*start>org.springframework.web.bind.annotation.RequestBody<method*end> Rule rule) {
if (StringUtils.isEmpty<method*start>org.springframework.util.StringUtils.isEmpty<method*end>(rule.getRuleId<method*start>com.navercorp.pinpoint.web.alarm.vo.Rule.getRuleId<method*end>())) {
Map<method*start>java.util.Map<method*end><String<method*start>java.lang.String<method*end>, String<method*start>java.lang.String<method*end>> result = new HashMap<method*start>java.util.HashMap<method*end><>();
result.put<method*start>java.util.Map.put<method*end>("errorCode", "500");
result.put<method*start>java.util.Map.put<method*end>("errorMessage", "there is not ruleId to delete alarm rule");
return result;
}
alarmService.deleteRule<method*start>com.navercorp.pinpoint.web.service.AlarmService.deleteRule<method*end>(rule);
Map<method*start>java.util.Map<method*end><String<method*start>java.lang.String<method*end>, String<method*start>java.lang.String<method*end>> result = new HashMap<method*start>java.util.HashMap<method*end><>();
result.put<method*start>java.util.Map.put<method*end>("result", "SUCCESS");
return result;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.