001 /* 002 * SonarQube, open source software quality management tool. 003 * Copyright (C) 2008-2014 SonarSource 004 * mailto:contact AT sonarsource DOT com 005 * 006 * SonarQube is free software; you can redistribute it and/or 007 * modify it under the terms of the GNU Lesser General Public 008 * License as published by the Free Software Foundation; either 009 * version 3 of the License, or (at your option) any later version. 010 * 011 * SonarQube is distributed in the hope that it will be useful, 012 * but WITHOUT ANY WARRANTY; without even the implied warranty of 013 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 014 * Lesser General Public License for more details. 015 * 016 * You should have received a copy of the GNU Lesser General Public License 017 * along with this program; if not, write to the Free Software Foundation, 018 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. 019 */ 020 package org.sonar.api.server.ws; 021 022 import com.google.common.base.Splitter; 023 import com.google.common.collect.Lists; 024 import org.apache.commons.lang.StringUtils; 025 import org.sonar.api.utils.DateUtils; 026 import org.sonar.api.utils.SonarException; 027 028 import javax.annotation.CheckForNull; 029 import java.util.Date; 030 import java.util.List; 031 032 /** 033 * @since 4.2 034 */ 035 public abstract class Request { 036 037 /** 038 * Returns the name of the HTTP method with which this request was made. Possible 039 * values are GET and POST. Others are not supported. 040 */ 041 public abstract String method(); 042 043 /** 044 * Returns a non-null value. To be used when parameter is required or has a default value. 045 * 046 * @throws java.lang.IllegalArgumentException is value is null or blank 047 */ 048 public String mandatoryParam(String key) { 049 String value = param(key); 050 if (value == null) { 051 throw new IllegalArgumentException(String.format("Parameter '%s' is missing", key)); 052 } 053 return value; 054 } 055 056 /** 057 * Returns a boolean value. To be used when parameter is required or has a default value. 058 * 059 * @throws java.lang.IllegalArgumentException is value is null or blank 060 */ 061 public boolean mandatoryParamAsBoolean(String key) { 062 String s = mandatoryParam(key); 063 return Boolean.parseBoolean(s); 064 } 065 066 /** 067 * Returns an int value. To be used when parameter is required or has a default value. 068 * 069 * @throws java.lang.IllegalArgumentException is value is null or blank 070 */ 071 public int mandatoryParamAsInt(String key) { 072 String s = mandatoryParam(key); 073 return Integer.parseInt(s); 074 } 075 076 /** 077 * Returns a long value. To be used when parameter is required or has a default value. 078 * 079 * @throws java.lang.IllegalArgumentException is value is null or blank 080 */ 081 public long mandatoryParamAsLong(String key) { 082 String s = mandatoryParam(key); 083 return Long.parseLong(s); 084 } 085 086 public <E extends Enum<E>> E mandatoryParamAsEnum(String key, Class<E> enumClass) { 087 return Enum.valueOf(enumClass, mandatoryParam(key)); 088 } 089 090 public List<String> mandatoryParamAsStrings(String key) { 091 List<String> values = paramAsStrings(key); 092 if (values == null) { 093 throw new IllegalArgumentException(String.format("Parameter '%s' is missing", key)); 094 } 095 return values; 096 } 097 098 @CheckForNull 099 public List<String> paramAsStrings(String key) { 100 String value = param(key); 101 if (value == null) { 102 return null; 103 } 104 return Lists.newArrayList(Splitter.on(',').omitEmptyStrings().trimResults().split(value)); 105 } 106 107 @CheckForNull 108 public abstract String param(String key); 109 110 /** 111 * @deprecated to be dropped in 4.4. Default values are declared in ws metadata 112 */ 113 @CheckForNull 114 @Deprecated 115 public String param(String key, @CheckForNull String defaultValue) { 116 return StringUtils.defaultString(param(key), defaultValue); 117 } 118 119 /** 120 * @deprecated to be dropped in 4.4. Default values must be declared in {@link org.sonar.api.server.ws.WebService} then 121 * this method can be replaced by {@link #mandatoryParamAsBoolean(String)}. 122 */ 123 @Deprecated 124 public boolean paramAsBoolean(String key, boolean defaultValue) { 125 String s = param(key); 126 return s == null ? defaultValue : Boolean.parseBoolean(s); 127 } 128 129 /** 130 * @deprecated to be dropped in 4.4. Default values must be declared in {@link org.sonar.api.server.ws.WebService} then 131 * this method can be replaced by {@link #mandatoryParamAsInt(String)}. 132 */ 133 @Deprecated 134 public int paramAsInt(String key, int defaultValue) { 135 String s = param(key); 136 return s == null ? defaultValue : Integer.parseInt(s); 137 } 138 139 /** 140 * @deprecated to be dropped in 4.4. Default values must be declared in {@link org.sonar.api.server.ws.WebService} then 141 * this method can be replaced by {@link #mandatoryParamAsLong(String)}. 142 */ 143 @Deprecated 144 public long paramAsLong(String key, long defaultValue) { 145 String s = param(key); 146 return s == null ? defaultValue : Long.parseLong(s); 147 } 148 149 150 @CheckForNull 151 public Boolean paramAsBoolean(String key) { 152 String s = param(key); 153 return s == null ? null : Boolean.parseBoolean(s); 154 } 155 156 @CheckForNull 157 public Integer paramAsInt(String key) { 158 String s = param(key); 159 return s == null ? null : Integer.parseInt(s); 160 } 161 162 @CheckForNull 163 public Long paramAsLong(String key) { 164 String s = param(key); 165 return s == null ? null : Long.parseLong(s); 166 } 167 168 @CheckForNull 169 public <E extends Enum<E>> E paramAsEnum(String key, Class<E> enumClass) { 170 String s = param(key); 171 return s == null ? null : Enum.valueOf(enumClass, s); 172 } 173 174 @CheckForNull 175 public <E extends Enum<E>> List<E> paramAsEnums(String key, Class<E> enumClass) { 176 String value = param(key); 177 if (value == null) { 178 return null; 179 } 180 Iterable<String> values = Splitter.on(',').omitEmptyStrings().trimResults().split(value); 181 List<E> result = Lists.newArrayList(); 182 for (String s : values) { 183 result.add(Enum.valueOf(enumClass, s)); 184 } 185 return result; 186 } 187 188 @CheckForNull 189 public Date paramAsDateTime(String key) { 190 String s = param(key); 191 if (s != null) { 192 try { 193 return DateUtils.parseDateTime(s); 194 } catch(SonarException notDateTime) { 195 try { 196 return DateUtils.parseDate(s); 197 } catch (SonarException notDateEither) { 198 throw new SonarException(String.format("'%s' cannot be parsed as either a date or date+time", s)); 199 } 200 } 201 } 202 return null; 203 } 204 205 @CheckForNull 206 public Date paramAsDate(String key) { 207 String s = param(key); 208 if (s != null) { 209 return DateUtils.parseDate(s); 210 } 211 return null; 212 } 213 }