src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
EmptyUri implements Uri { @Override public boolean isHierarchical() { return false; } @Override Optional<? extends Scheme> scheme(); @Override Optional<? extends Authority> authority(); @Override Path path(); @Override Optional<? extends Query> query(); @Override Optional<? extends Fragment> fragment(); @Override boolean isHierarchical(); @Override boolean isAbsolute(); final static EmptyUri INSTANCE; }
|
@Test public void testIsHierarchical() throws Exception { assertFalse(new EmptyUri().isHierarchical()); }
|
EmptyUri implements Uri { @Override public boolean isAbsolute() { return false; } @Override Optional<? extends Scheme> scheme(); @Override Optional<? extends Authority> authority(); @Override Path path(); @Override Optional<? extends Query> query(); @Override Optional<? extends Fragment> fragment(); @Override boolean isHierarchical(); @Override boolean isAbsolute(); final static EmptyUri INSTANCE; }
|
@Test public void testIsAbsolute() throws Exception { assertFalse(new EmptyUri().isAbsolute()); }
|
Text implements UriEncoded { @Override public int length() { if (mText == null) { int len = mDelegate.host().length(); if (mDelegate.userInfo().isPresent()) { len += mDelegate.userInfo().value().length() + 1; } Optional<Integer> optionalPort = mDelegate.port(); if (optionalPort.isPresent()) { int port = optionalPort.value(); if (port < 10) { len += 2; } else if (port < 100) { len += 3; } else if (port < 1000) { len += 4; } else if (port < 10000) { len += 5; } else if (port < 100000) { len += 6; } else { throw new IllegalArgumentException(String.format("Port number %d out of range (<100000)", port)); } } return len; } return mText.length(); } Text(Authority delegate); @Override int length(); @Override char charAt(int i); @Override UriEncoded subSequence(int startIndex, int endIndex); @Override String toString(); @Override UriEncoded normalized(); @Override CharSequence decoded(String charset); @Override CharSequence decoded(); }
|
@Test public void testLength() throws Exception { assertEquals(0, new Text(new StructuredAuthority(new Precoded(""))).length()); assertEquals(4, new Text(new StructuredAuthority(new Precoded("host"))).length()); assertEquals(8, new Text(new StructuredAuthority(new Precoded("host"), 123)).length()); assertEquals(9, new Text(new StructuredAuthority(new Precoded("user"), new Precoded("host"))).length()); assertEquals(13, new Text(new StructuredAuthority(new Precoded("user"), new Precoded("host"), 123)).length()); assertEquals(5, new Text(new StructuredAuthority(new Precoded("user"), new Precoded(""))).length()); assertEquals(4, new Text(new StructuredAuthority(new Precoded(""), 123)).length()); assertEquals(9, new Text(new StructuredAuthority(new Precoded("user"), new Precoded(""), 123)).length()); }
|
Text implements UriEncoded { @Override public char charAt(int i) { return toString().charAt(i); } Text(Authority delegate); @Override int length(); @Override char charAt(int i); @Override UriEncoded subSequence(int startIndex, int endIndex); @Override String toString(); @Override UriEncoded normalized(); @Override CharSequence decoded(String charset); @Override CharSequence decoded(); }
|
@Ignore @Test public void testCharAt() throws Exception { }
|
Text implements UriEncoded { @Override public UriEncoded subSequence(int startIndex, int endIndex) { if (startIndex == 0 && endIndex == toString().length()) { return this; } return new Precoded(toString().subSequence(startIndex, endIndex)); } Text(Authority delegate); @Override int length(); @Override char charAt(int i); @Override UriEncoded subSequence(int startIndex, int endIndex); @Override String toString(); @Override UriEncoded normalized(); @Override CharSequence decoded(String charset); @Override CharSequence decoded(); }
|
@Ignore @Test public void testSubSequence() throws Exception { }
|
Text implements UriEncoded { @Override public String toString() { if (mText == null) { StringBuilder builder = new StringBuilder(64); Optional<? extends UriEncoded> mUserInfo = mDelegate.userInfo(); if (mUserInfo.isPresent()) { builder.append(mUserInfo.value().normalized()); builder.append('@'); } builder.append(mDelegate.host().normalized()); Optional<Integer> port = mDelegate.port(); if (port.isPresent()) { builder.append(':'); builder.append((int) port.value()); } mText = builder.toString(); } return mText; } Text(Authority delegate); @Override int length(); @Override char charAt(int i); @Override UriEncoded subSequence(int startIndex, int endIndex); @Override String toString(); @Override UriEncoded normalized(); @Override CharSequence decoded(String charset); @Override CharSequence decoded(); }
|
@Ignore @Test public void testToString() throws Exception { }
|
Text implements UriEncoded { @Override public UriEncoded normalized() { return this; } Text(Authority delegate); @Override int length(); @Override char charAt(int i); @Override UriEncoded subSequence(int startIndex, int endIndex); @Override String toString(); @Override UriEncoded normalized(); @Override CharSequence decoded(String charset); @Override CharSequence decoded(); }
|
@Test public void testNormalized() throws Exception { assertEquals("user@host:123", new Text(new StructuredAuthority(new Precoded("user"), new Precoded("host"), 123)).normalized().toString()); assertEquals("user%40host@host:123", new Text(new StructuredAuthority(new Precoded("%75%73%65%72%40%68%6F%73%74"), new Precoded("%68%6F%73%74"), 123)).normalized().toString()); }
|
Text implements UriEncoded { @Override public CharSequence decoded(String charset) throws UnsupportedEncodingException { throw new UnsupportedOperationException("an Authority can't be decoded as a whole"); } Text(Authority delegate); @Override int length(); @Override char charAt(int i); @Override UriEncoded subSequence(int startIndex, int endIndex); @Override String toString(); @Override UriEncoded normalized(); @Override CharSequence decoded(String charset); @Override CharSequence decoded(); }
|
@Ignore @Test public void testDecoded() throws Exception { }
|
OptionalLazyAuthority implements Optional<Authority>, Parsed { @Override public boolean isPresent() { return authority().isPresent(); } OptionalLazyAuthority(UriEncoded uriEncoded); @Override boolean isPresent(); @Override Authority value(Authority defaultValue); @Override Authority value(); @Override int parsedLength(); }
|
@Test public void testIsPresent() throws Exception { assertTrue(new OptionalLazyAuthority(new Precoded(" assertTrue(new OptionalLazyAuthority(new Precoded(" assertTrue(new OptionalLazyAuthority(new Precoded(" assertTrue(new OptionalLazyAuthority(new Precoded(" assertTrue(new OptionalLazyAuthority(new Precoded(" assertTrue(new OptionalLazyAuthority(new Precoded(" assertTrue(new OptionalLazyAuthority(new Precoded(" assertTrue(new OptionalLazyAuthority(new Precoded(" assertTrue(new OptionalLazyAuthority(new Precoded(" assertTrue(new OptionalLazyAuthority(new Precoded(" assertFalse(new OptionalLazyAuthority(new Precoded("")).isPresent()); assertFalse(new OptionalLazyAuthority(new Precoded("/")).isPresent()); assertFalse(new OptionalLazyAuthority(new Precoded("test")).isPresent()); assertFalse(new OptionalLazyAuthority(new Precoded("about:")).isPresent()); }
|
OptionalLazyAuthority implements Optional<Authority>, Parsed { @Override public Authority value(Authority defaultValue) { return authority().value(defaultValue); } OptionalLazyAuthority(UriEncoded uriEncoded); @Override boolean isPresent(); @Override Authority value(Authority defaultValue); @Override Authority value(); @Override int parsedLength(); }
|
@Test public void testValue() throws Exception { assertEquals("", new OptionalLazyAuthority(new Precoded(" assertEquals("test", new OptionalLazyAuthority(new Precoded(" assertEquals("test", new OptionalLazyAuthority(new Precoded(" assertEquals("example.com", new OptionalLazyAuthority(new Precoded(" assertEquals("example.com", new OptionalLazyAuthority(new Precoded(" assertEquals("", new OptionalLazyAuthority(new Precoded(" assertEquals("test", new OptionalLazyAuthority(new Precoded(" assertEquals("test", new OptionalLazyAuthority(new Precoded(" assertEquals("example.com", new OptionalLazyAuthority(new Precoded(" assertEquals("example.com", new OptionalLazyAuthority(new Precoded(" assertFalse(new OptionalLazyAuthority(new Precoded(" assertFalse(new OptionalLazyAuthority(new Precoded(" assertFalse(new OptionalLazyAuthority(new Precoded(" assertTrue(new OptionalLazyAuthority(new Precoded(" assertEquals("test", new OptionalLazyAuthority(new Precoded(" assertEquals("te:st", new OptionalLazyAuthority(new Precoded(" assertTrue(new OptionalLazyAuthority(new Precoded(" assertEquals("test", new OptionalLazyAuthority(new Precoded(" assertEquals("te:st", new OptionalLazyAuthority(new Precoded(" assertFalse(new OptionalLazyAuthority(new Precoded(" assertFalse(new OptionalLazyAuthority(new Precoded(" assertFalse(new OptionalLazyAuthority(new Precoded(" assertTrue(new OptionalLazyAuthority(new Precoded(" assertEquals("test", new OptionalLazyAuthority(new Precoded(" assertEquals("te:st", new OptionalLazyAuthority(new Precoded(" assertTrue("example.com", new OptionalLazyAuthority(new Precoded(" assertEquals("test", new OptionalLazyAuthority(new Precoded(" assertEquals("te:st", new OptionalLazyAuthority(new Precoded(" assertFalse(new OptionalLazyAuthority(new Precoded(" assertFalse(new OptionalLazyAuthority(new Precoded(" assertEquals(123, (int) new OptionalLazyAuthority(new Precoded(" assertFalse(new OptionalLazyAuthority(new Precoded(" assertFalse(new OptionalLazyAuthority(new Precoded(" assertFalse(new OptionalLazyAuthority(new Precoded(" assertEquals(123, (int) new OptionalLazyAuthority(new Precoded(" assertEquals(123, (int) new OptionalLazyAuthority(new Precoded(" assertEquals(123, (int) new OptionalLazyAuthority(new Precoded(" assertFalse(new OptionalLazyAuthority(new Precoded(" assertFalse(new OptionalLazyAuthority(new Precoded(" assertEquals(123, (int) new OptionalLazyAuthority(new Precoded(" assertFalse(new OptionalLazyAuthority(new Precoded(" assertFalse(new OptionalLazyAuthority(new Precoded(" assertFalse(new OptionalLazyAuthority(new Precoded(" assertEquals(123, (int) new OptionalLazyAuthority(new Precoded(" assertEquals(123, (int) new OptionalLazyAuthority(new Precoded(" assertEquals(123, (int) new OptionalLazyAuthority(new Precoded(" }
|
StringScheme implements Scheme { @Override public int length() { return mScheme.length(); } StringScheme(String scheme); @Override int length(); @Override char charAt(int i); @Override CharSequence subSequence(int i, int i1); @Override String toString(); }
|
@Test public void testLength() throws Exception { assertEquals(4, new StringScheme("http").length()); }
@Test(expected = IllegalArgumentException.class) public void testLengthIllegalChar() throws Exception { new StringScheme("http_").length(); }
|
Precoded implements UriEncoded { @Override public int length() { return mEnd - mStart; } Precoded(CharSequence encoded); private Precoded(CharSequence encoded, int start, int end); @Override UriEncoded normalized(); @Override CharSequence decoded(String charset); @Override CharSequence decoded(); @Override int length(); @Override char charAt(int i); @Override UriEncoded subSequence(int startIndex, int endIndex); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }
|
@Test public void length() throws Exception { }
|
StringScheme implements Scheme { @Override public char charAt(int i) { return mScheme.charAt(i); } StringScheme(String scheme); @Override int length(); @Override char charAt(int i); @Override CharSequence subSequence(int i, int i1); @Override String toString(); }
|
@Test public void testCharAt() throws Exception { assertEquals('h', new StringScheme("http").charAt(0)); assertEquals('t', new StringScheme("http").charAt(1)); assertEquals('t', new StringScheme("http").charAt(2)); assertEquals('p', new StringScheme("http").charAt(3)); }
@Test(expected = IllegalArgumentException.class) public void testCharAtIllegalChar() throws Exception { new StringScheme("http_").charAt(0); }
|
StringScheme implements Scheme { @Override public CharSequence subSequence(int i, int i1) { return mScheme.subSequence(i, i1); } StringScheme(String scheme); @Override int length(); @Override char charAt(int i); @Override CharSequence subSequence(int i, int i1); @Override String toString(); }
|
@Test public void testSubSequence() throws Exception { assertEquals("tt", new StringScheme("http").subSequence(1, 3).toString()); }
@Test(expected = IllegalArgumentException.class) public void testSubSequenceIllegalChar() throws Exception { new StringScheme("http_").subSequence(1, 2); }
|
StringScheme implements Scheme { @Override public String toString() { return mScheme.toString(); } StringScheme(String scheme); @Override int length(); @Override char charAt(int i); @Override CharSequence subSequence(int i, int i1); @Override String toString(); }
|
@Test public void testToString() throws Exception { assertEquals("http", new StringScheme("http").toString()); }
@Test(expected = IllegalArgumentException.class) public void testToStringIllegalChar() throws Exception { new StringScheme("http_").toString(); }
|
OptionalLazyScheme implements Optional<Scheme>, Parsed { @Override public boolean isPresent() { return scheme().isPresent(); } OptionalLazyScheme(UriEncoded uriEncoded); @Override boolean isPresent(); @Override Scheme value(Scheme defaultValue); @Override Scheme value(); @Override int parsedLength(); }
|
@Test public void isPresent() throws Exception { assertTrue(new OptionalLazyScheme(new Precoded("http: assertTrue(new OptionalLazyScheme(new Precoded("http: assertTrue(new OptionalLazyScheme(new Precoded("mailto:[email protected]")).isPresent()); assertTrue(new OptionalLazyScheme(new Precoded("example.com:123")).isPresent()); assertFalse(new OptionalLazyScheme(new Precoded(" assertFalse(new OptionalLazyScheme(new Precoded("")).isPresent()); assertFalse(new OptionalLazyScheme(new Precoded(":")).isPresent()); assertFalse(new OptionalLazyScheme(new Precoded("123abc:")).isPresent()); assertFalse(new OptionalLazyScheme(new Precoded("[email protected]:123")).isPresent()); }
|
OptionalLazyScheme implements Optional<Scheme>, Parsed { @Override public Scheme value(Scheme defaultValue) { return scheme().value(defaultValue); } OptionalLazyScheme(UriEncoded uriEncoded); @Override boolean isPresent(); @Override Scheme value(Scheme defaultValue); @Override Scheme value(); @Override int parsedLength(); }
|
@Test public void value() throws Exception { assertEquals("http", new OptionalLazyScheme(new Precoded("http: assertEquals("http", new OptionalLazyScheme(new Precoded("http: assertEquals("mailto", new OptionalLazyScheme(new Precoded("mailto:[email protected]")).value().toString()); assertEquals("example.com", new OptionalLazyScheme(new Precoded("example.com:123")).value().toString()); }
@Test(expected = NoSuchElementException.class) public void valueFail1() throws Exception { new OptionalLazyScheme(new Precoded(" }
@Test(expected = NoSuchElementException.class) public void valueFail2() throws Exception { new OptionalLazyScheme(new Precoded("")).value(); }
@Test(expected = NoSuchElementException.class) public void valueFail3() throws Exception { new OptionalLazyScheme(new Precoded("[email protected]:123")).value(); }
@Test public void valueWithDefault() throws Exception { assertEquals("http", new OptionalLazyScheme(new Precoded("http: assertEquals("http", new OptionalLazyScheme(new Precoded("http: assertEquals("mailto", new OptionalLazyScheme(new Precoded("mailto:[email protected]")).value(new StringScheme("default")).toString()); assertEquals("example.com", new OptionalLazyScheme(new Precoded("example.com:123")).value(new StringScheme("default")).toString()); assertEquals("default", new OptionalLazyScheme(new Precoded(" assertEquals("default", new OptionalLazyScheme(new Precoded("")).value(new StringScheme("default")).toString()); assertEquals("default", new OptionalLazyScheme(new Precoded("[email protected]:123")).value(new StringScheme("default")).toString()); }
|
Precoded implements UriEncoded { @Override public char charAt(int i) { if (i < 0) { throw new ArrayIndexOutOfBoundsException(String.format("Index %d is negative.", i)); } if (mStart + i >= mEnd) { throw new ArrayIndexOutOfBoundsException(String.format("Index %d exceeds length %d", i, length())); } return mEncoded.charAt(i + mStart); } Precoded(CharSequence encoded); private Precoded(CharSequence encoded, int start, int end); @Override UriEncoded normalized(); @Override CharSequence decoded(String charset); @Override CharSequence decoded(); @Override int length(); @Override char charAt(int i); @Override UriEncoded subSequence(int startIndex, int endIndex); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }
|
@Test public void charAt() throws Exception { }
|
Schemes { private Schemes() { } private Schemes(); final static Scheme FTP; final static Scheme HTTP; final static Scheme HTTPS; final static Scheme MAILTO; }
|
@Test public void testSchemes() { assertEquals("ftp", Schemes.FTP.toString()); assertEquals("http", Schemes.HTTP.toString()); assertEquals("https", Schemes.HTTPS.toString()); assertEquals("mailto", Schemes.MAILTO.toString()); }
|
TextValueType implements ValueType<CharSequence> { @Override public CharSequence parsedValue(CharSequence valueText) { return valueText; } @Override CharSequence parsedValue(CharSequence valueText); @Override CharSequence serializedValue(CharSequence value); final static TextValueType INSTANCE; }
|
@Test public void testParsedValue() throws Exception { assertEquals("", TextValueType.INSTANCE.parsedValue("")); assertEquals("abc", TextValueType.INSTANCE.parsedValue("abc")); }
|
TextValueType implements ValueType<CharSequence> { @Override public CharSequence serializedValue(CharSequence value) { return value; } @Override CharSequence parsedValue(CharSequence valueText); @Override CharSequence serializedValue(CharSequence value); final static TextValueType INSTANCE; }
|
@Test public void testSerializedValue() throws Exception { assertEquals("", TextValueType.INSTANCE.serializedValue("")); assertEquals("abc", TextValueType.INSTANCE.serializedValue("abc")); }
|
UrlEncodedParameter implements Parameter { @Override public CharSequence name() { parse(); try { return mName.decoded(mCharSet); } catch (UnsupportedEncodingException e) { throw new RuntimeException(String.format("CharSet %s not supported by Runtime", mCharSet)); } } UrlEncodedParameter(UriEncoded encodedPair); UrlEncodedParameter(UriEncoded encodedParameter, String charSet); @Override CharSequence name(); @Override CharSequence textValue(); }
|
@Test public void name() throws Exception { assertEquals("test", new UrlEncodedParameter(new Precoded("test")).name().toString()); assertEquals("testa", new UrlEncodedParameter(new Precoded("test%61")).name().toString()); assertEquals("test=", new UrlEncodedParameter(new Precoded("test%3D")).name().toString()); assertEquals("test", new UrlEncodedParameter(new Precoded("test=123")).name().toString()); assertEquals("testa", new UrlEncodedParameter(new Precoded("test%61=123%34")).name().toString()); assertEquals("test=", new UrlEncodedParameter(new Precoded("test%3D=123%3D")).name().toString()); }
|
UrlEncodedParameter implements Parameter { @Override public CharSequence textValue() { parse(); try { return mValue.decoded(mCharSet); } catch (UnsupportedEncodingException e) { throw new RuntimeException(String.format("CharSet %s not supported by Runtime", mCharSet)); } } UrlEncodedParameter(UriEncoded encodedPair); UrlEncodedParameter(UriEncoded encodedParameter, String charSet); @Override CharSequence name(); @Override CharSequence textValue(); }
|
@Test public void textValue() throws Exception { assertEquals("", new UrlEncodedParameter(new Precoded("test")).textValue().toString()); assertEquals("", new UrlEncodedParameter(new Precoded("test%61")).textValue().toString()); assertEquals("", new UrlEncodedParameter(new Precoded("test%3D")).textValue().toString()); assertEquals("123", new UrlEncodedParameter(new Precoded("test=123")).textValue().toString()); assertEquals("1234", new UrlEncodedParameter(new Precoded("test%61=123%34")).textValue().toString()); assertEquals("123=", new UrlEncodedParameter(new Precoded("test%3D=123%3D")).textValue().toString()); }
|
Precoded implements UriEncoded { @Override public UriEncoded subSequence(int startIndex, int endIndex) { if (startIndex == 0 && endIndex == length()) { return this; } if (endIndex < startIndex) { throw new ArrayIndexOutOfBoundsException(String.format("Start index %d < end index %d.", startIndex, endIndex)); } if (startIndex < 0) { throw new ArrayIndexOutOfBoundsException(String.format("Start index %d is negative.", startIndex)); } if (mStart + endIndex > mEnd) { throw new ArrayIndexOutOfBoundsException(String.format("End index %d exceeds length %d", endIndex, length())); } return new Precoded(mEncoded, startIndex + mStart, endIndex + mStart); } Precoded(CharSequence encoded); private Precoded(CharSequence encoded, int start, int end); @Override UriEncoded normalized(); @Override CharSequence decoded(String charset); @Override CharSequence decoded(); @Override int length(); @Override char charAt(int i); @Override UriEncoded subSequence(int startIndex, int endIndex); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }
|
@Test public void subSequence() throws Exception { assertEquals(new Precoded("123"), new Precoded("abc123xyz").subSequence(3, 6)); assertEquals("123", new Precoded("abc123xyz").subSequence(3, 6).toString()); }
|
Precoded implements UriEncoded { @Override public int hashCode() { return normalized().hashCode(); } Precoded(CharSequence encoded); private Precoded(CharSequence encoded, int start, int end); @Override UriEncoded normalized(); @Override CharSequence decoded(String charset); @Override CharSequence decoded(); @Override int length(); @Override char charAt(int i); @Override UriEncoded subSequence(int startIndex, int endIndex); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }
|
@Test public void testHashCode() throws Exception { }
|
Precoded implements UriEncoded { @Override public boolean equals(Object obj) { return obj instanceof UriEncoded && normalized().equals(obj); } Precoded(CharSequence encoded); private Precoded(CharSequence encoded, int start, int end); @Override UriEncoded normalized(); @Override CharSequence decoded(String charset); @Override CharSequence decoded(); @Override int length(); @Override char charAt(int i); @Override UriEncoded subSequence(int startIndex, int endIndex); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }
|
@Test public void equals() throws Exception { }
|
ToggleJsonNode { public static JsonNode fromString(String json) { try { return DEFAULT_OBJECT_READER.readTree(json); } catch (IOException err) { return MissingNode.getInstance(); } } static JsonNode fromString(String json); static JsonNode findByKey(Iterator<JsonNode> iterator, String key); static boolean matchesCohort(JsonNode node, Optional<String> cohortOpt); static JsonNode findByCohort(JsonNode node, Optional<String> cohortOpt); static final ObjectReader DEFAULT_OBJECT_READER; }
|
@Test public void producesJsonNodeFromString() { final JsonNode node = ToggleJsonNode.fromString("{\"foo\": 4, \"bar\": true}"); assertThat(node.isMissingNode()).isFalse(); assertThat(node.fieldNames()).containsOnly("foo", "bar"); assertThat(node.path("foo").intValue()).isEqualTo(4); assertThat(node.path("bar").booleanValue()).isTrue(); }
@Test public void producesMissingNodeForMalformedJsonString() { final JsonNode node = ToggleJsonNode.fromString("not a json string"); assertThat(node.isMissingNode()).isTrue(); }
|
ToggleJsonNode { public static JsonNode findByCohort(JsonNode node, Optional<String> cohortOpt) { if (node.isObject() && ToggleJsonNode.matchesCohort(node, cohortOpt)) { return node; } else if (node.isArray()) { final Iterator<JsonNode> iterator = node.elements(); while (iterator.hasNext()) { final JsonNode containedNode = iterator.next(); if (containedNode.isObject() && ToggleJsonNode.matchesCohort(containedNode, cohortOpt)) { return containedNode; } } return MissingNode.getInstance(); } else { return MissingNode.getInstance(); } } static JsonNode fromString(String json); static JsonNode findByKey(Iterator<JsonNode> iterator, String key); static boolean matchesCohort(JsonNode node, Optional<String> cohortOpt); static JsonNode findByCohort(JsonNode node, Optional<String> cohortOpt); static final ObjectReader DEFAULT_OBJECT_READER; }
|
@Test public void returnsMissingNodeForNonexistentCohortInArrayNode() { final ObjectNode filterNode = JsonNodeFactory.instance.objectNode() .put("type", "cohort") .put("target", "employee") .put("value", 10000); final ArrayNode expected = JsonNodeFactory.instance.arrayNode() .add(filterNode); assertThat(ToggleJsonNode.findByCohort(expected, Optional.of("na")).isMissingNode()).isTrue(); }
@Test public void findsFilterNodeByCohortFromObjectNode() { final String cohort = "employee"; final ObjectNode expected = JsonNodeFactory.instance.objectNode() .put("type", "cohort") .put("target", cohort) .put("value", 10000); assertThat(ToggleJsonNode.findByCohort(expected, Optional.of(cohort))).isEqualTo(expected); }
@Test public void findsFilterNodeByCohortFromArrayNode() { final String cohort = "employee"; final ObjectNode filterNode = JsonNodeFactory.instance.objectNode() .put("type", "cohort") .put("target", cohort) .put("value", 10000); final ArrayNode expected = JsonNodeFactory.instance.arrayNode() .add(filterNode); assertThat(ToggleJsonNode.findByCohort(expected, Optional.of(cohort))).isEqualTo(filterNode); }
@Test public void returnsMissingNodeForNonexistentCohortInObjectNode() { final ObjectNode expected = JsonNodeFactory.instance.objectNode() .put("type", "cohort") .put("target", "employee") .put("value", 10000); assertThat(ToggleJsonNode.findByCohort(expected, Optional.of("na")).isMissingNode()).isTrue(); }
|
CachingToggleMap extends ToggleMap<K, T> { @Override public Toggle<T> apply(K key) { return new Toggle<T>() { @Override protected boolean test(T t, Optional<String> cohortOpt) { Toggle<T> underlying = null; try { underlying = cache.get(key); fallbackCache.put(key, underlying); } catch (NoSuchElementException err) { underlying = fallbackCache.getOrDefault(key, ALWAYS_FALSE); } if (cohortOpt.isPresent()) { return underlying .withCohort(cohortOpt.get()) .test(t); } else { return underlying.test(t); } } }; } CachingToggleMap(ToggleMap<K, T> underlying, CaffeineSpec cacheSpec); CachingToggleMap(ToggleMap<K, T> underlying, String cacheSpec); @Override Toggle<T> apply(K key); @Override Set<K> keySet(); }
|
@Test public void testReadFromUnderlyingToggleMapOnMiss() { when(underlying.apply(onKey)).thenReturn(toggle); final CachingToggleMap<String, Integer> toggleMap = new CachingToggleMap<>(underlying, CaffeineSpec.parse("maximumSize=3")); assertThat(toggleMap.apply(onKey).test(1)).isTrue(); verify(underlying).apply(eq(onKey)); }
@Test public void testReadFromCacheOnHit() { when(underlying.apply(onKey)).thenReturn(toggle); final CachingToggleMap<String, Integer> toggleMap = new CachingToggleMap<>(underlying, CaffeineSpec.parse("maximumSize=3")); toggleMap.apply(onKey).test(1); toggleMap.apply(onKey).test(2); verify(underlying, times(1)).apply(eq(onKey)); }
@Test public void testCohortsPassedThrough() { final Toggle<Integer> mockToggle = mock(Toggle.class); when(mockToggle.withCohort(anyString())).thenReturn(mockToggle); when(mockToggle.test(eq(1))).thenReturn(toggle.test(1)); when(underlying.apply(onKey)).thenReturn(mockToggle); final CachingToggleMap<String, Integer> toggleMap = new CachingToggleMap<>(underlying, CaffeineSpec.parse("maximumSize=3")); toggleMap.apply(onKey) .withCohort("foo") .test(1); verify(underlying, times(1)).apply(eq(onKey)); verify(mockToggle, times(1)).withCohort(eq("foo")); verify(mockToggle, times(1)).test(eq(1)); }
@Test public void testFallsBackToLastReadToggleOnFailedReadFromUnderlying() { when(underlying.apply(onKey)) .thenReturn(toggle) .thenThrow(new NoSuchElementException()); final CachingToggleMap<String, Integer> toggleMap = new CachingToggleMap<>(underlying, CaffeineSpec.parse("maximumSize=0")); final Toggle<Integer> t = toggleMap.apply(onKey); assertThat(t.test(1)).isTrue(); assertThat(t.test(1)).isTrue(); verify(underlying, times(2)).apply(eq(onKey)); }
|
CachingToggleMap extends ToggleMap<K, T> { @Override public Set<K> keySet() { final Set<K> underlyingKeySet = underlying.keySet(); underlyingKeySet.forEach(cache::refresh); return underlyingKeySet; } CachingToggleMap(ToggleMap<K, T> underlying, CaffeineSpec cacheSpec); CachingToggleMap(ToggleMap<K, T> underlying, String cacheSpec); @Override Toggle<T> apply(K key); @Override Set<K> keySet(); }
|
@Test public void testReadKeySetFromUnderlying() { final Set<String> expectedKeySet = new HashSet(); expectedKeySet.add(onKey); expectedKeySet.add(offKey); when(underlying.keySet()).thenReturn(expectedKeySet); final CachingToggleMap<String, Integer> toggleMap = new CachingToggleMap<>(underlying, CaffeineSpec.parse("maximumSize=3")); assertThat(toggleMap.keySet()).containsOnly(onKey, offKey); }
|
ToggleJsonNode { public static JsonNode findByKey(Iterator<JsonNode> iterator, String key) { while (iterator.hasNext()) { final JsonNode node = iterator.next(); if (node.path("key").textValue().equals(key)) { return node; } } return MissingNode.getInstance(); } static JsonNode fromString(String json); static JsonNode findByKey(Iterator<JsonNode> iterator, String key); static boolean matchesCohort(JsonNode node, Optional<String> cohortOpt); static JsonNode findByCohort(JsonNode node, Optional<String> cohortOpt); static final ObjectReader DEFAULT_OBJECT_READER; }
|
@Test public void findsToggleNodeByKey() { final String key = "/feature/admin_widget"; final ObjectNode expected = JsonNodeFactory.instance.objectNode() .put("key", key) .put("value", 10000); final List<JsonNode> list = new ArrayList<>(); list.add(expected); final JsonNode found = ToggleJsonNode.findByKey(list.iterator(), key); assertThat(found).isEqualTo(expected); }
@Test public void returnsMissingNodeOnNonexistentKey() { final ObjectNode expected = JsonNodeFactory.instance.objectNode() .put("key", "/feature/admin_widget") .put("value", 10000); final List<JsonNode> list = new ArrayList<>(); list.add(expected); final JsonNode found = ToggleJsonNode.findByKey(list.iterator(), "/feature/na"); assertThat(found.isMissingNode()).isTrue(); }
|
ToggleJsonNode { public static boolean matchesCohort(JsonNode node, Optional<String> cohortOpt) { return node.isObject() && node.hasNonNull("type") && node.path("type").isTextual() && node.path("type").textValue().equals("cohort") && cohortOpt.isPresent() && node.hasNonNull("target") && node.path("target").isTextual() && node.path("target").textValue().equals(cohortOpt.get()); } static JsonNode fromString(String json); static JsonNode findByKey(Iterator<JsonNode> iterator, String key); static boolean matchesCohort(JsonNode node, Optional<String> cohortOpt); static JsonNode findByCohort(JsonNode node, Optional<String> cohortOpt); static final ObjectReader DEFAULT_OBJECT_READER; }
|
@Test public void returnsTrueOnMatchedCohort() { final String cohort = "employee"; final ObjectNode expected = JsonNodeFactory.instance.objectNode() .put("type", "cohort") .put("target", cohort) .put("value", 10000); assertThat(ToggleJsonNode.matchesCohort(expected, Optional.of(cohort))).isTrue(); }
@Test public void returnsFalseOnMismatchedCohort() { final ObjectNode expected = JsonNodeFactory.instance.objectNode() .put("type", "cohort") .put("target", "employee") .put("value", 10000); assertThat(ToggleJsonNode.matchesCohort(expected, Optional.of("na"))).isFalse(); }
@Test public void returnsFalseOnMalformedJsonNode() { final ObjectNode expected = JsonNodeFactory.instance.objectNode() .put("type", 4) .put("bar", true); assertThat(ToggleJsonNode.matchesCohort(expected, Optional.of("na"))).isFalse(); }
|
AliPayServiceImpl implements IAliPayService { public JSONObject createTemporaryOrder(OrderFormData data){ int totalPrice = 0; List<CommodityAmount> caList = data.getCaList(); for (CommodityAmount info:caList){ totalPrice+=info.getAmount(); } JSONObject info = new JSONObject(); try { Long orderId = OrderUtils.getOrderId(); data.getOrder().setId(orderId); data.getOrder().setPrice(totalPrice); String orderAttach = JSON.toJSONString(data); String order = OrderUtils.createAlipayInfo(orderAttach,String.valueOf(orderId),"惊喜商城-"+orderId,"惊喜商城",String.valueOf(totalPrice)); info.put("id",orderId); info.put("order",order); putCacheOrderFormData(data); } catch (Exception e) { e.printStackTrace(); LOG.error("订单创建失败",e); throw new RuntimeException("订单创建失败"); } return info; } JSONObject createTemporaryOrder(OrderFormData data); @CachePut(key = "#data.order.id+''+#data.order.userAccountId") OrderFormData putCacheOrderFormData(OrderFormData data); @Cacheable(key = "#data.order.id+''+#data.order.userAccountId") OrderFormData getCacheTemporaryOrder(OrderFormData data); @CacheEvict(key = "#data.order.id+''+#data.order.userAccountId") void removeTemporaryOrder(OrderFormData data); @Override boolean checkAliPayOrderValidator(Map params); @Override String createSign(Long accountId, OrderFormData formData); }
|
@Test public void testCreateTemporaryOrder() throws Exception { OrderFormData data = new OrderFormData(); List<CommodityAmount> amounts = new ArrayList<>(); CommodityAmount commodityAmount = new CommodityAmount(); commodityAmount.setAmount(10); commodityAmount.setCommodityId(100L); amounts.add(commodityAmount); data.setCaList(amounts); Orders orders = new Orders(); orders.setPrice(10); orders.setId(200l); orders.setUserAccountId(400l); data.setOrder(orders); JSONObject temporaryOrder = payService.createTemporaryOrder(data); String id = temporaryOrder.getString("id"); String order = temporaryOrder.getString("order"); System.out.println(id); System.out.println(order); }
|
ShareServiceImpl implements IShareService { @Override public List<Map<String, Object>> selectByCommId(Long commId, Long lastCommId) { Long tempId = commMapper.selectTempIdByCommId(commId); List<Long> commIdList = commMapper.selectCommIdByTempId(tempId, lastCommId, Settings.PAGE_LOAD_SIZE_10); List<Map<String, Object>> mapList = null; List<Share> shareList; if (!commIdList.isEmpty()) { shareList = new ArrayList<>(); for (Long aCommId : commIdList) { Share share = shareMapper.selectPassedCommShare(aCommId); if (null != share) shareList.add(share); } mapList = createShareMapList(null, shareList); } return mapList; } @Override String getUpToken(String suffix); @Override String uploadToQiniu(MultipartFile file); @Override String getUpToken(); @Override boolean isReady(); @Override Share getShare(Long shareId); @Override boolean addShare(Long accountId, Long commId, String desc, List<MultipartFile> imgs); @Override boolean deleteShare(Long shareid); @Override List<Share> selectShare(Long accountid, Long lastshareid, Integer tag); @Override boolean friendsShare(Long account); @Override List<Map<String, Object>> selectByUserAccountId(Long accountId, Long lastCommId); @Override List<Map<String, Object>> selectAll(Long lastCommId); @Override List<Map<String, Object>> selectByCommId(Long commId, Long lastCommId); List<String> imgUrl(Share s); }
|
@Test public void testSelectByCommId() throws Exception { }
|
ShareServiceImpl implements IShareService { @Override public boolean addShare(Long accountId, Long commId, String desc, List<MultipartFile> imgs) { Share hasShare = shareMapper.selectByCommId(commId); if (null != hasShare) return false; Commodity com = commMapper.selectByKey(commId); if ((com.getShareState() == null ? 0 : com.getShareState()) == 1) return false; Share share = new Share(); share.setCommodityId(commId); share.setIssueDate(new Date().getTime()); share.setParticulars(desc); share.setUserAccountId(accountId); shareMapper.insertByGeneratedKeys(share); for (MultipartFile img : imgs) { ShareImg shareImg = new ShareImg(); String filename = uploadToQiniu(img); String url = qiniuhost + filename; shareImg.setShareId(share.getId()); shareImg.setShareImgUrl(url); shareImgMapper.insert(shareImg); } commMapper.updateShareStateByCommodityId(com.getId(), SHARE_STATE_YET); commodityHistoryMapper.updateShareStateByCommodityId(com.getId(), SHARE_STATE_YET); return true; } @Override String getUpToken(String suffix); @Override String uploadToQiniu(MultipartFile file); @Override String getUpToken(); @Override boolean isReady(); @Override Share getShare(Long shareId); @Override boolean addShare(Long accountId, Long commId, String desc, List<MultipartFile> imgs); @Override boolean deleteShare(Long shareid); @Override List<Share> selectShare(Long accountid, Long lastshareid, Integer tag); @Override boolean friendsShare(Long account); @Override List<Map<String, Object>> selectByUserAccountId(Long accountId, Long lastCommId); @Override List<Map<String, Object>> selectAll(Long lastCommId); @Override List<Map<String, Object>> selectByCommId(Long commId, Long lastCommId); List<String> imgUrl(Share s); }
|
@Test public void testAddShare() throws Exception { shareService.addShare(10000L, 20L, "111", new ArrayList<MultipartFile>()); }
|
ShareServiceImpl implements IShareService { @Override public boolean deleteShare(Long shareid) { Share share = new Share(); share.setId(shareid); return shareMapper.delete(share) > 0; } @Override String getUpToken(String suffix); @Override String uploadToQiniu(MultipartFile file); @Override String getUpToken(); @Override boolean isReady(); @Override Share getShare(Long shareId); @Override boolean addShare(Long accountId, Long commId, String desc, List<MultipartFile> imgs); @Override boolean deleteShare(Long shareid); @Override List<Share> selectShare(Long accountid, Long lastshareid, Integer tag); @Override boolean friendsShare(Long account); @Override List<Map<String, Object>> selectByUserAccountId(Long accountId, Long lastCommId); @Override List<Map<String, Object>> selectAll(Long lastCommId); @Override List<Map<String, Object>> selectByCommId(Long commId, Long lastCommId); List<String> imgUrl(Share s); }
|
@Test public void testDeleteShare() throws Exception { Share s = new Share(); s.setId(1l); boolean b = shareService.deleteShare(s.getId()); Assert.assertTrue(b); }
|
ShareServiceImpl implements IShareService { @Override public List<Share> selectShare(Long accountid, Long lastshareid, Integer tag) { Share share = new Share(); if (tag == Settings.INITIALIZE_ENTER_STATUS) { share.setUserAccountId(accountid); return shareMapper.select(share); } else if (tag == Settings.DROP_DOWN_REFRESH) { return null; } return null; } @Override String getUpToken(String suffix); @Override String uploadToQiniu(MultipartFile file); @Override String getUpToken(); @Override boolean isReady(); @Override Share getShare(Long shareId); @Override boolean addShare(Long accountId, Long commId, String desc, List<MultipartFile> imgs); @Override boolean deleteShare(Long shareid); @Override List<Share> selectShare(Long accountid, Long lastshareid, Integer tag); @Override boolean friendsShare(Long account); @Override List<Map<String, Object>> selectByUserAccountId(Long accountId, Long lastCommId); @Override List<Map<String, Object>> selectAll(Long lastCommId); @Override List<Map<String, Object>> selectByCommId(Long commId, Long lastCommId); List<String> imgUrl(Share s); }
|
@Test public void testSelectShare() throws Exception { }
|
ApproveServiceImpl implements IApproveService { @Override public boolean addApproveMassage(Approve approve) { int insert = mapper.insert(approve); if(insert>0){ return true; } return false; } @Override boolean addApproveMassage(Approve approve); @Override List<Approve> select(Long userAccount); @Override boolean update(Approve approve); }
|
@Test public void testAddApproveMassage() throws Exception { Approve a = new Approve(); a.setUserAccountId(1l); a.setApproveDate(new Date().getTime()); a.setPhoneNumber(15283590214l); a.setRealName("小张"); a.setSite("成都市"); a.setRealNumber("123123123123123123"); boolean b = approve.addApproveMassage(a); Assert.assertTrue(b); }
|
ApproveServiceImpl implements IApproveService { @Override public List<Approve> select(Long userAccount) { Approve a = new Approve(); a.setUserAccountId(userAccount); return mapper.select(a); } @Override boolean addApproveMassage(Approve approve); @Override List<Approve> select(Long userAccount); @Override boolean update(Approve approve); }
|
@Test public void testSelect() throws Exception { List<Approve> select = approve.select(1l); System.out.println(select.get(0).getRealName()); Assert.assertNotNull(select); }
|
ApproveServiceImpl implements IApproveService { @Override public boolean update(Approve approve) { int i = mapper.updateByPrimaryKeySelective(approve); if(i>0){ return true; } return false; } @Override boolean addApproveMassage(Approve approve); @Override List<Approve> select(Long userAccount); @Override boolean update(Approve approve); }
|
@Test public void testUpdate() throws Exception { Approve a = new Approve(); a.setId(1l); a.setApproveDate(new Date().getTime()); a.setRealName("小王"); boolean update = approve.update(a); Assert.assertTrue(update); }
|
RedPacketsServiceImpl implements IRedPacketsService { @Override public List<Map<String, Object>> selectAllByUserAccountId(Long accountId) { List<Map<String, Object>> mapList = new ArrayList<>(); List<RedPackets> list = mapper.selectByAccount(accountId); for (RedPackets r : list) { Map<String, Object> map = new HashMap<>(); map.put("id", r.getId()); map.put("name", r.getName()); map.put("userAccountId", r.getUserAccountId()); map.put("validDate", r.getValidDate()); map.put("overdueDate", r.getOverdueDate()); map.put("usePrice", r.getUsePrice()); map.put("worth", r.getWorth()); Integer useState = r.getUseState(); map.put("useState", useState); if (overdue(r)) { map.put("overdue", Settings.RED_PACKET_overdue); } else { map.put("overdue", Settings.RED_PACKET_overdue_not); } if (useState == Settings.RED_PACKET_USE_STATE_USED || overdue(r)) { map.put("usable", Settings.STATE_DISABLE); } else { map.put("usable", Settings.STATE_AVAILABLE); } mapList.add(map); } return mapList; } @Override List<Map<String, Object>> selectAllByUserAccountId(Long accountId); @Override boolean useRedPacket(Long AccountId, Long rpId); @Override RedPackets selectOne(Long accountId,Long rpId); boolean overdue(RedPackets r); }
|
@Test public void testSelectAllByUserAccountId() throws Exception { List<Map<String, Object>> list = ird.selectAllByUserAccountId(10000l); System.out.println(list.size()); }
|
RedPacketsServiceImpl implements IRedPacketsService { @Override public boolean useRedPacket(Long AccountId, Long rpId) { RedPackets rp = new RedPackets(); rp.setUserAccountId(AccountId); rp.setId(rpId); RedPackets redPacket = mapper.selectOne(rp); redPacket.setUseState(Settings.RED_PACKET_USE_STATE_USED); return mapper.updateByPrimaryKey(redPacket) > 0; } @Override List<Map<String, Object>> selectAllByUserAccountId(Long accountId); @Override boolean useRedPacket(Long AccountId, Long rpId); @Override RedPackets selectOne(Long accountId,Long rpId); boolean overdue(RedPackets r); }
|
@Test public void testUseRedPacket() throws Exception { }
|
RedPacketsServiceImpl implements IRedPacketsService { public boolean overdue(RedPackets r) { Date date = new Date(); if (r.getOverdueDate() > date.getTime()) return false; return true; } @Override List<Map<String, Object>> selectAllByUserAccountId(Long accountId); @Override boolean useRedPacket(Long AccountId, Long rpId); @Override RedPackets selectOne(Long accountId,Long rpId); boolean overdue(RedPackets r); }
|
@Test public void testOverdue() throws Exception { }
|
AliPayServiceImpl implements IAliPayService { @CacheEvict(key = "#data.order.id+''+#data.order.userAccountId") public void removeTemporaryOrder(OrderFormData data){ } JSONObject createTemporaryOrder(OrderFormData data); @CachePut(key = "#data.order.id+''+#data.order.userAccountId") OrderFormData putCacheOrderFormData(OrderFormData data); @Cacheable(key = "#data.order.id+''+#data.order.userAccountId") OrderFormData getCacheTemporaryOrder(OrderFormData data); @CacheEvict(key = "#data.order.id+''+#data.order.userAccountId") void removeTemporaryOrder(OrderFormData data); @Override boolean checkAliPayOrderValidator(Map params); @Override String createSign(Long accountId, OrderFormData formData); }
|
@Test public void testRemoveTemporaryOrder() throws Exception { }
|
LuckCodesServiceImpl implements ILuckCodesService { @Override public List<LuckCodes> select(Long commodId) { LuckCodes luck = new LuckCodes(); luck.setCommodityId(commodId); return this.mapper.select(luck); } @Override List<LuckCodes> select(Long commodId); @Override boolean delete(Long id); @Override List<LuckCodes> selectByUserId(Long accountId); @Override Long getTempCount(); @Override void addToTemp(Set<LuckCodeTemplate> set); @Override List<LuckCodes> selectRange(long count); @Override void insertCodeList(List<LuckCodes> list); @Override int getCount(Long accountId, Long commodityId); }
|
@Test public void testCreateLuckCode() throws Exception { LuckCodes luckCodes = new LuckCodes(); List<LuckCodes> select = mapper.select(luckCodes); for (LuckCodes l : select){ LuckCodeTemplate template = templateMapper.selectById(l.getLuckCodeTemplateId()); LuckCodes luckCodes1 = new LuckCodes(); luckCodes1.setId(l.getId()); mapper.updateByPrimaryKeySelective(luckCodes1); } }
@Test public void testSelect() throws Exception { List<LuckCodes> select = luckService.select(1l); Assert.assertNotNull(select); }
|
LuckCodesServiceImpl implements ILuckCodesService { @Override public boolean delete(Long id) { int i = mapper.deleteByPrimaryKey(id); if (i > 0) { return true; } return false; } @Override List<LuckCodes> select(Long commodId); @Override boolean delete(Long id); @Override List<LuckCodes> selectByUserId(Long accountId); @Override Long getTempCount(); @Override void addToTemp(Set<LuckCodeTemplate> set); @Override List<LuckCodes> selectRange(long count); @Override void insertCodeList(List<LuckCodes> list); @Override int getCount(Long accountId, Long commodityId); }
|
@Test public void testDelete() throws Exception { boolean delete = luckService.delete(1l); Assert.assertTrue(delete); }
|
UserCodesHistoryServiceImpl implements IUserCodesHistoryService { @Override public boolean addToHistory(UserCodesHistory userhis) { int insert = uchMapper.insert(userhis); if(insert>0){ return true; } return false; } @Override boolean addToHistory(UserCodesHistory userhis); @Override List<UserCodesHistory> selectByUserAccount(Long accounId); @Override List<UserCodesHistory> selectByCommodId(Long commodId); @Override List<UserCodesHistory> selectAll(); }
|
@Test public void testAddToHistory() throws Exception { UserCodesHistory userch = new UserCodesHistory(); userch.setId(1l); userch.setUserAccountId(1l); userch.setCommodityId(1l); boolean b = usercodesHistory.addToHistory(userch); Assert.assertTrue(b); }
|
UserCodesHistoryServiceImpl implements IUserCodesHistoryService { @Override public List<UserCodesHistory> selectByUserAccount(Long accounId) { UserCodesHistory user = new UserCodesHistory(); user.setUserAccountId(accounId); return uchMapper.select(user); } @Override boolean addToHistory(UserCodesHistory userhis); @Override List<UserCodesHistory> selectByUserAccount(Long accounId); @Override List<UserCodesHistory> selectByCommodId(Long commodId); @Override List<UserCodesHistory> selectAll(); }
|
@Test public void testSelectByUserAccount() throws Exception { List<UserCodesHistory> userCodesHistories = usercodesHistory.selectByCommodId(1l); Assert.assertNotNull(userCodesHistories); }
|
UserCodesHistoryServiceImpl implements IUserCodesHistoryService { @Override public List<UserCodesHistory> selectByCommodId(Long commodId) { UserCodesHistory user = new UserCodesHistory(); user.setCommodityId(commodId); return uchMapper.select(user); } @Override boolean addToHistory(UserCodesHistory userhis); @Override List<UserCodesHistory> selectByUserAccount(Long accounId); @Override List<UserCodesHistory> selectByCommodId(Long commodId); @Override List<UserCodesHistory> selectAll(); }
|
@Test public void testSelectByCommodId() throws Exception { List<UserCodesHistory> histories = usercodesHistory.selectByCommodId(2l); Assert.assertNotNull(histories); }
|
UserCodesHistoryServiceImpl implements IUserCodesHistoryService { @Override public List<UserCodesHistory> selectAll() { return uchMapper.selectAll(); } @Override boolean addToHistory(UserCodesHistory userhis); @Override List<UserCodesHistory> selectByUserAccount(Long accounId); @Override List<UserCodesHistory> selectByCommodId(Long commodId); @Override List<UserCodesHistory> selectAll(); }
|
@Test public void testSelectAll() throws Exception { List<UserCodesHistory> histories = usercodesHistory.selectAll(); Assert.assertNotNull(histories); }
|
CommodityTypeServiceImpl implements ICommodityTypeService { @Override public boolean addType(CommodityType commtype) { int insert = ctMapper.insert(commtype); if (insert > 0) { return true; } return false; } @Override boolean addType(CommodityType commtype); @Override boolean hideType(Integer id); @Override boolean updateType(CommodityType commtype); @Override CommodityType selectType(String name); @Override List<CommodityType> selectAvailable(); @Override List<CommodityType> selectAll(); }
|
@Test public void testAddType() throws Exception { CommodityType ct = new CommodityType(); ct.setName("手机"); ct.setState(1); boolean b = commodType.addType(ct); Assert.assertTrue(b,"保存成功！！！！"); }
|
CommodityTypeServiceImpl implements ICommodityTypeService { @Override public boolean hideType(Integer id) { CommodityType c = new CommodityType(); c.setId(id); c.setState(1); int i = ctMapper.updateByPrimaryKeySelective(c); if (i > 0) { return true; } return false; } @Override boolean addType(CommodityType commtype); @Override boolean hideType(Integer id); @Override boolean updateType(CommodityType commtype); @Override CommodityType selectType(String name); @Override List<CommodityType> selectAvailable(); @Override List<CommodityType> selectAll(); }
|
@Test public void testHideType() throws Exception { boolean b = commodType.hideType(0); Assert.assertTrue(b); }
|
CommodityTypeServiceImpl implements ICommodityTypeService { @Override public boolean updateType(CommodityType commtype) { int i = ctMapper.updateByPrimaryKeySelective(commtype); if (i > 0) { return true; } return false; } @Override boolean addType(CommodityType commtype); @Override boolean hideType(Integer id); @Override boolean updateType(CommodityType commtype); @Override CommodityType selectType(String name); @Override List<CommodityType> selectAvailable(); @Override List<CommodityType> selectAll(); }
|
@Test public void testUpdateType() throws Exception { CommodityType ct = new CommodityType(); ct.setId(1); ct.setName("电脑"); ct.setState(1); commodType.updateType(ct); }
|
AliPayServiceImpl implements IAliPayService { @Override public String createSign(Long accountId, OrderFormData formData) throws Exception { Date date = new Date(); Orders order = formData.getOrder(); List<CommodityAmount> caList = formData.getCaList(); Long orderId = getRebuildOrderId(accountId, date, order); String orderTradeNo = new SimpleDateFormat("yyyyMMddHHmmss").format(new Date()) + orderId; Map<String, String> map = new HashMap<String, String>(); map.put("app_id", AlipayConfig.partner); map.put("method", "alipay.trade.app.pay"); map.put("format", "json"); map.put("charset", "utf-8"); map.put("sign_type", "RSA"); map.put("version", "1.0"); map.put("notify_url", "===="); Map<String, String> m = new HashMap<String, String>(); m.put("body", "测试"); m.put("subject", ""); m.put("out_trade_no", orderTradeNo); m.put("timeout_express", "30m"); m.put("total_amount", order.getPrice()+""); m.put("seller_id", AlipayConfig.partner); m.put("product_code", "QUICK_MSECURITY_PAY"); JSONObject bizcontentJson= JSON.parseObject(JSONObject.toJSONString(m)); map.put("biz_content", bizcontentJson.toString()); String rsaSign = AlipaySignature.rsaSign(map, AlipayConfig.private_key, "utf-8"); Map<String, String> map4 = new HashMap<String, String>(); map4.put("method", "alipay.trade.app.pay"); map4.put("format", "json"); map4.put("charset", "utf-8"); map4.put("sign_type", "RSA"); map4.put("version", "1.0"); map4.put("notify_url", URLEncoder.encode("==","UTF-8")); map4.put("biz_content", URLEncoder.encode(bizcontentJson.toString(), "UTF-8")); String json4 = ""; json4=json4 + "&sign=" + URLEncoder.encode(rsaSign, "UTF-8"); return json4.toString(); } JSONObject createTemporaryOrder(OrderFormData data); @CachePut(key = "#data.order.id+''+#data.order.userAccountId") OrderFormData putCacheOrderFormData(OrderFormData data); @Cacheable(key = "#data.order.id+''+#data.order.userAccountId") OrderFormData getCacheTemporaryOrder(OrderFormData data); @CacheEvict(key = "#data.order.id+''+#data.order.userAccountId") void removeTemporaryOrder(OrderFormData data); @Override boolean checkAliPayOrderValidator(Map params); @Override String createSign(Long accountId, OrderFormData formData); }
|
@Test public void testCreateSign() throws Exception { }
|
CommodityTypeServiceImpl implements ICommodityTypeService { @Override public CommodityType selectType(String name) { CommodityType ct = new CommodityType(); ct.setName(name); return (CommodityType) ctMapper.select(ct); } @Override boolean addType(CommodityType commtype); @Override boolean hideType(Integer id); @Override boolean updateType(CommodityType commtype); @Override CommodityType selectType(String name); @Override List<CommodityType> selectAvailable(); @Override List<CommodityType> selectAll(); }
|
@Test public void testSelectType() throws Exception { CommodityType typeName = commodType.selectType("电脑"); Assert.assertNotNull(typeName,"查询成功!!!!"); }
|
HotSearchServiceImpl implements IHotSearchService { @Override public boolean addHotSearch(String keywords) { if (null == keywords) return false; HotSearch hs = new HotSearch(); hs.setName(keywords); HotSearch hotSearch = mapper.selectOne(hs); if (null != hotSearch) { return mapper.updateRecommend(hotSearch.getId(),hotSearch.getFrequency()+1) > 0; } else { hs.setFrequency(1L); return mapper.insert(hs) > 0; } } @Override boolean addHotSearch(String keywords); @Override List<String> queryRecommend(); }
|
@Test public void testAddHotSearch() throws Exception { boolean b = service.addHotSearch("请问"); Assert.assertTrue(b); }
|
HotSearchServiceImpl implements IHotSearchService { @Override public List<String> queryRecommend() { return mapper.selectRecommend(); } @Override boolean addHotSearch(String keywords); @Override List<String> queryRecommend(); }
|
@Test public void testQueryRecommend() throws Exception { }
|
ExchangeMethodServiceImpl implements IExchangeMethodService { @Override public boolean orTrue(Long accountId, Long commodityId) { List<Map<String, Object>> maps = selectUserRechargeCardPrize(accountId, commodityId); if (maps != null && maps.size() != 0) { return true; } return false; } @Override boolean exchangeToCash(String exchangeTerraceName, String terraceAccount, Long commodityId, Long accountId); @Override List<Map<String, Object>> selectUserRechargeCardPrize(Long accountId, Long commodityId); @Override boolean orTrue(Long accountId, Long commodityId); @Override Map<String, Object> selectUserRechargeCardExchangeProcess(Long accountId, Long commodityId); Map<String, Object> demo2(Long commodityId); Map<String, Object> demo3(Long accountId, Long commodityId); @Override Map<String, Object> temp1(Long accountId, Long commodityId); @Override Map<String, Object> temp2(Long accountId, Long commodityId, Long addressId); @Override Map<String, Object> temp3(Long accountId, Long commodityId); @Override boolean temp4(Long accountId, Long commodityId); @Override Map<String, Object> temp5(Long accountId, Long commodityId); @Override String cardPassword(String card); }
|
@Test public void testExchangeToGold() throws Exception { boolean b = service.orTrue(10000l, 45l); Assert.assertTrue(b); }
@Test public void testOrTrue() throws Exception { }
|
ExchangeMethodServiceImpl implements IExchangeMethodService { @Override public boolean exchangeToCash(String exchangeTerraceName, String terraceAccount, Long commodityId, Long accountId) { Commoditys com = comMapper.selectByKey(commodityId); CommodityTemplate template = templateMapper.selectByPrimaryKey(com.getTempId()); Integer money = template.getWithdrawalsMoney(); User user = userMapper.selectByPrimaryKey(accountId); String realName = user.getRealName(); ExchangeCashMessage exCash = new ExchangeCashMessage(); exCash.setUserAccountId(accountId); exCash.setExchangeAmount(money); exCash.setExchangeTerraceName(exchangeTerraceName); exCash.setState(0); exCash.setTerraceAccount(terraceAccount); exCash.setUserRealName(realName); return cashMapper.insert(exCash) > 0; } @Override boolean exchangeToCash(String exchangeTerraceName, String terraceAccount, Long commodityId, Long accountId); @Override List<Map<String, Object>> selectUserRechargeCardPrize(Long accountId, Long commodityId); @Override boolean orTrue(Long accountId, Long commodityId); @Override Map<String, Object> selectUserRechargeCardExchangeProcess(Long accountId, Long commodityId); Map<String, Object> demo2(Long commodityId); Map<String, Object> demo3(Long accountId, Long commodityId); @Override Map<String, Object> temp1(Long accountId, Long commodityId); @Override Map<String, Object> temp2(Long accountId, Long commodityId, Long addressId); @Override Map<String, Object> temp3(Long accountId, Long commodityId); @Override boolean temp4(Long accountId, Long commodityId); @Override Map<String, Object> temp5(Long accountId, Long commodityId); @Override String cardPassword(String card); }
|
@Test public void testExchangeToCash() throws Exception { }
|
ExchangeMethodServiceImpl implements IExchangeMethodService { @Override public List<Map<String, Object>> selectUserRechargeCardPrize(Long accountId, Long commodityId) { List<Map<String, Object>> mapList = new ArrayList<>(); Commodity history = commMapper.selectComIdAndUser(accountId, commodityId); CommodityTemplate template = templateMapper.selectById(history.getTempId()); Map<String, Object> map = new HashMap<>(); map.put("commodityName", template.getName()); map.put("roundTime", history.getRoundTime()); map.put("commodityId", history.getId()); map.put("endTime", history.getEndTime()); map.put("coverImgUrl", template.getCoverImgUrl()); map.put("exchangeState", history.getExchangeState()); mapList.add(map); return mapList; } @Override boolean exchangeToCash(String exchangeTerraceName, String terraceAccount, Long commodityId, Long accountId); @Override List<Map<String, Object>> selectUserRechargeCardPrize(Long accountId, Long commodityId); @Override boolean orTrue(Long accountId, Long commodityId); @Override Map<String, Object> selectUserRechargeCardExchangeProcess(Long accountId, Long commodityId); Map<String, Object> demo2(Long commodityId); Map<String, Object> demo3(Long accountId, Long commodityId); @Override Map<String, Object> temp1(Long accountId, Long commodityId); @Override Map<String, Object> temp2(Long accountId, Long commodityId, Long addressId); @Override Map<String, Object> temp3(Long accountId, Long commodityId); @Override boolean temp4(Long accountId, Long commodityId); @Override Map<String, Object> temp5(Long accountId, Long commodityId); @Override String cardPassword(String card); }
|
@Test public void testSelectUserRechargeCardPrize() throws Exception { }
|
ExchangeMethodServiceImpl implements IExchangeMethodService { @Override public Map<String, Object> selectUserRechargeCardExchangeProcess(Long accountId, Long commodityId) { Map<String, Object> map = new HashMap<>(); Commodity history = commMapper.selectByPrimaryKey(commodityId); ExchangeWay way = ewMapper.selectById(history.getExchangeWay()); CommodityTemplate template = templateMapper.selectById(history.getTempId()); Share share = shareMapper.selectByCommId(commodityId); map.put("commodityName", template.getName()); map.put("coverImgUrl", template.getCoverImgUrl()); map.put("exchangeState", history.getExchangeState()); map.put("userBuyNumber", history.getBuyNumber()); map.put("genre", template.getGenre()); map.put("commodityId", commodityId); map.put("prizeState", "正在兑奖中"); map.put("size", 0); map.put("worth", 0); map.put("cardNumberList", new ArrayList<>()); map.put("expressNumber", null); map.put("expressName", null); map.put("expressState", 0); map.put("ContactName", null); map.put("ContactPhone", null); map.put("ContactAddress", null); map.put("state", 2); map.put("exchangeWay", history.getExchangeWay()); if (share != null) { map.put("shareState", 1); } else { map.put("shareState", 0); } if (way != null) { map.put("exchangeName", way.getName()); } else { map.put("exchangeName", "未选择兑换方式"); } int f = history.getExchangeState(); if (f == 1) { int g = history.getExchangeWay(); if (g == 1) { map.putAll(demo2(commodityId)); } else if (g == 2) { map.putAll(demo3(accountId, commodityId)); } else if (g == 5) { map.put("ContactName", template.getContactName()); map.put("ContactPhone", template.getContactPhone()); map.put("ContactAddress", template.getContactAddress()); map.put("state", 3); } } System.out.println(map); return map; } @Override boolean exchangeToCash(String exchangeTerraceName, String terraceAccount, Long commodityId, Long accountId); @Override List<Map<String, Object>> selectUserRechargeCardPrize(Long accountId, Long commodityId); @Override boolean orTrue(Long accountId, Long commodityId); @Override Map<String, Object> selectUserRechargeCardExchangeProcess(Long accountId, Long commodityId); Map<String, Object> demo2(Long commodityId); Map<String, Object> demo3(Long accountId, Long commodityId); @Override Map<String, Object> temp1(Long accountId, Long commodityId); @Override Map<String, Object> temp2(Long accountId, Long commodityId, Long addressId); @Override Map<String, Object> temp3(Long accountId, Long commodityId); @Override boolean temp4(Long accountId, Long commodityId); @Override Map<String, Object> temp5(Long accountId, Long commodityId); @Override String cardPassword(String card); }
|
@Test public void testSelectUserRechargeCardExchangeProcess() throws Exception { Map<String, Object> map = service.selectUserRechargeCardExchangeProcess(10000l, 45l); System.out.println(map.get("commodityName")); }
|
ExchangeMethodServiceImpl implements IExchangeMethodService { public Map<String, Object> demo2(Long commodityId) { List<Map<String, Object>> mapList = new ArrayList<>(); Map<String, Object> map = new HashMap<>(); Commodity commoditys = commMapper.selectByPrimaryKey(commodityId); CommodityTemplate template = templateMapper.selectByPrimaryKey(commoditys.getTempId()); Integer num = template.getCardNum(); Integer money = template.getCardMoney(); Integer type = template.getCardType(); List<Card> list = cardMapper.selectByCommodityId(commodityId); if (list == null || list.size() == 0) { Card card = new Card(); card.setState(0); card.setCorporation(type); card.setCommodityId(0l); card.setMoney(money); List<Card> cards = cardMapper.select(card); if (cards.size() >= num) { map.put("size", num); for (int i = 0; i < num; i++) { Map<String, Object> map1 = new HashMap<>(); map1.put("cardNumber", cards.get(i).getCardNum()); map1.put("password", null); map1.put("state", cards.get(i).getState()); mapList.add(map1); cardMapper.updateCardState(cards.get(i).getCardNum(), commodityId); } map.put("cardNumberList", mapList); map.put("worth", money); } else { map.put("size", 0); map.put("cardNumberList", new ArrayList<>()); map.put("worth", 0); } } else { map.put("size", num); for (Card card : list) { Map<String, Object> map1 = new HashMap<>(); map1.put("cardNumber", card.getCardNum()); map1.put("password", card.getPassword()); map1.put("state", card.getState()); mapList.add(map1); } map.put("cardNumberList", mapList); map.put("worth", money); } return map; } @Override boolean exchangeToCash(String exchangeTerraceName, String terraceAccount, Long commodityId, Long accountId); @Override List<Map<String, Object>> selectUserRechargeCardPrize(Long accountId, Long commodityId); @Override boolean orTrue(Long accountId, Long commodityId); @Override Map<String, Object> selectUserRechargeCardExchangeProcess(Long accountId, Long commodityId); Map<String, Object> demo2(Long commodityId); Map<String, Object> demo3(Long accountId, Long commodityId); @Override Map<String, Object> temp1(Long accountId, Long commodityId); @Override Map<String, Object> temp2(Long accountId, Long commodityId, Long addressId); @Override Map<String, Object> temp3(Long accountId, Long commodityId); @Override boolean temp4(Long accountId, Long commodityId); @Override Map<String, Object> temp5(Long accountId, Long commodityId); @Override String cardPassword(String card); }
|
@Test public void testDemo2() throws Exception { }
|
GenerateServiceImpl implements IGenerateService { @Override public void keepRound(long roundNum) { List<CommodityTemplate> temps = commodityService.getNotKeepRoundTemplate(roundNum); for (CommodityTemplate temp : temps) { final Integer count = temp.getCount(); for (int i = count; i < roundNum; i++) { generateCommodity(temp.getId(), temp.getBuyTotalNumber()); } } } @Override void generateCommodity(long tempId, long luckCodeCount); @Override String generateLuckCodes(long total); @Override void connectLuckCodes(long commodityId, long count); @Override void keepRound(long roundNum); @Override Long generateNewRoundTime(); }
|
@Test public void testKeepRound() throws Exception{ service.keepRound(3); }
|
ShoppingCartServiceImpl implements IShoppingCartService { @Override public boolean addCommodityToCart(Long accountId, Long commId, Integer count) { if (null == accountId) return false; ShoppingCart cart = new ShoppingCart(); cart.setUserAccountId(accountId); cart.setCommodityId(commId); cart.setNumber(count); cart.setAddDate(new Date().getTime()); return mapper.insert(cart) > 0; } @Override boolean addCommodityToCart(Long accountId, Long commId, Integer count); @Override boolean deleteCommodity(Long accountId, Long commId); @Override boolean updateCommodity(Long accountId, Long commId, Integer count); @Override List<Map<String, Object>> selectByAccount(Long accountId); }
|
@Test public void testAddCommodityToCart() throws Exception { ShoppingCart s = new ShoppingCart(); s.setUserAccountId(2l); s.setCommodityId(10l); s.setNumber(10); s.setAddDate(new Date().getTime()); boolean b = service.addCommodityToCart(1L,1L,1); Assert.assertTrue(b); }
|
CommodityImgServiceImlpl implements ICommodityImgService { @Override public boolean addImage(CommodityImg commodImg) { int insert = commodityImg.insert(commodImg); if (insert > 0) { return true; } return false; } @Override boolean addImage(CommodityImg commodImg); @Override boolean deleteImage(Long id); @Override CommodityImg selectImg(Long id); @Override List<CommodityImg> selectAll(); }
|
@Test public void testAddImage() throws Exception { CommodityImg ci = new CommodityImg(); ci.setUrl("de.com"); ci.setAddTime(System.currentTimeMillis()); ci.setState(1); boolean b = commodImg.addImage(ci); Assert.assertTrue(b); }
|
CommodityImgServiceImlpl implements ICommodityImgService { @Override public boolean deleteImage(Long id) { return commodityImg.deleteByPrimaryKey(id) > 0; } @Override boolean addImage(CommodityImg commodImg); @Override boolean deleteImage(Long id); @Override CommodityImg selectImg(Long id); @Override List<CommodityImg> selectAll(); }
|
@Test public void testDeleteImage() throws Exception { boolean b = commodImg.deleteImage(1l); Assert.assertTrue(b); }
|
CommodityImgServiceImlpl implements ICommodityImgService { @Override public CommodityImg selectImg(Long id) { return commodityImg.selectByPrimaryKey(id); } @Override boolean addImage(CommodityImg commodImg); @Override boolean deleteImage(Long id); @Override CommodityImg selectImg(Long id); @Override List<CommodityImg> selectAll(); }
|
@Test public void testSelectImg() throws Exception { CommodityImg commodityImg = commodImg.selectImg(1l); Assert.assertNotNull(commodityImg, "不是空对象"); }
|
CommodityServiceImpl implements ICommodityService { @Override public Map<String, Object> selectCommodity(User user, Long commodId) { Commoditys com = commsMapper.selectByKey(commodId); if (null == com) return null; commMapper.updateViewNum(commodId, com.getViewNum() + 1); Map<String, Object> map = new HashMap<>(); String nextRound = null; Long nextRoundId = null; if (com.getStateId() == 3 || com.getStateId() == 2) { Commoditys comh = null; List<Long> longs = commMapper.selectBefore(com.getTempId(), com.getId()); if (longs.size() != 0) { comh = commsMapper.selectByKey(longs.get(0)); } if (comh == null) { map.put("beforeLottery", new HashMap<>()); } else if (com.getStateId() == 3) { map.put("beforeLottery", mapBefore(comh)); } } if (com.getStateId() == 2) { List<Commoditys> commsList = commsMapper.selectNextRoundComm(com.getTempId(), Settings.COMMODITY_STATE_ON_SALE); if (!commsList.isEmpty()) { Commoditys commoditys = commsList.get(0); nextRound = commoditys.getRoundTime() + "期正在火热进行中"; nextRoundId = commoditys.getId(); } } if (com.getStateId() == 1) { Commoditys byKey = commsMapper.selectByKey(commodId); map.put("beforeLottery", mapBefore(byKey)); List<Commoditys> commsList = commsMapper.selectNextRoundComm(com.getTempId(), Settings.COMMODITY_STATE_ON_SALE); if (!commsList.isEmpty()) { Commoditys commoditys = commsList.get(0); nextRound = commoditys.getRoundTime() + "期正在火热进行中"; nextRoundId = commoditys.getId(); } } String msg = "0"; if (null != user) { Integer amount1 = luckCodeMapper.countUserCommAmount(user.getAccountId(), commodId); Integer amount2 = userHistoryMapper.countHistoryUserCommAmount(user.getAccountId(), commodId); msg = amount1 + amount2 + ""; } map.put("user", msg); map.put("nextRound", nextRound); map.put("nextRoundId", nextRoundId); map.put("commId", commodId); map.put("minNum", com.getMinimum()); map.put("coverImg", com.getCoverImgUrl()); map.put("imgUrls", listUrl(commodId)); map.put("onState", com.getStateId()); map.put("commodityName", com.getName()); map.put("buyTotal", com.getBuyTotalNumber()); map.put("buyCurrent", com.getBuyTotalNumber() - com.getBuyCurrentNumber()); map.put("roundTime", com.getRoundTime()); map.put("countDown", ServiceUtils.getResidualLotterySeconds(com)); map.put("descUrl", com.getCommodityDescUrl()); map.put("partake", listPartake(commodId)); map.put("guessLike", listMap3()); return map; } @Override boolean addCommodity(Commoditys commod); @Override boolean delete(Long id); @Override Commoditys selectByid(Long id); @Override List<Commoditys> selectTypeAll(String commodType); @Override int selectCount(Integer commodityTypeId); @Override List<Commoditys> selectAll(); @Override List<Map<String, Object>> selectByStyle(Integer type, Long lastCommId); @Override List<Map<String, Object>> selectOnLottery(Integer page); @Override List<Map<String, Object>> selectOneOnLottery(Long commId); @Override Map<String, Object> selectCommodity(User user, Long commodId); List<Map<String, Object>> listMap3(); List<String> listUrl(Long commodId); Map<String, Object> mapBefore(Commoditys comh); List<Map<String, Object>> listPartake(Long commodId); Map<String, Object> map1(Long userAccountId); Map<String, Object> map2(Long commodId, Long userAccountId); @Override List<Map<String, Object>> selectPaging(Integer categoryId, String commName, Long lastCommId); List<Map<String, Object>> type1(Integer categoryId, String commName, Long lastCommId); List<Map<String, Object>> byType(Integer categoryId, Long lastCommId); List<Map<String, Object>> type4(String commName, Long lastCommId); List<Map<String, Object>> forPut(List<Commoditys> list); @Override List<Map<String, Object>> selectHeight(Long lastCommId); @Override Long generateNewRoundTime(); @Override List<Map<String, Object>> selectNewestAnnounceComm(Long lastCommId); @Override List<Map> selectThePastAnnouncedCommList(Long commId); @Override String getContent(Long commodityId); @Override long getMaxRoundTime(); @Override List<CommodityTemplate> getNotKeepRoundTemplate(long roundNum); @Override Commodity getNextCommodity(Long id); @Override Commodity groundNext(Long id); @Override Commoditys getDetails(Long id); @Override Commoditys selectOnSellCommodities(Long id); @Override List<CommodityAmount> selectAmounts(Long orderId); }
|
@Test public void testSelectCommodity() throws Exception { }
|
CommodityServiceImpl implements ICommodityService { @Override public List<Map<String, Object>> selectPaging(Integer categoryId, String commName, Long lastCommId) { if (null != categoryId && null != commName) { return type1(categoryId, commName, lastCommId); } else if (null == categoryId && null == commName) { return byType(1, lastCommId); } else if (null != categoryId && null == commName) { return byType(categoryId, lastCommId); } else if (null == categoryId && null != commName) { return type4(commName, lastCommId); } return null; } @Override boolean addCommodity(Commoditys commod); @Override boolean delete(Long id); @Override Commoditys selectByid(Long id); @Override List<Commoditys> selectTypeAll(String commodType); @Override int selectCount(Integer commodityTypeId); @Override List<Commoditys> selectAll(); @Override List<Map<String, Object>> selectByStyle(Integer type, Long lastCommId); @Override List<Map<String, Object>> selectOnLottery(Integer page); @Override List<Map<String, Object>> selectOneOnLottery(Long commId); @Override Map<String, Object> selectCommodity(User user, Long commodId); List<Map<String, Object>> listMap3(); List<String> listUrl(Long commodId); Map<String, Object> mapBefore(Commoditys comh); List<Map<String, Object>> listPartake(Long commodId); Map<String, Object> map1(Long userAccountId); Map<String, Object> map2(Long commodId, Long userAccountId); @Override List<Map<String, Object>> selectPaging(Integer categoryId, String commName, Long lastCommId); List<Map<String, Object>> type1(Integer categoryId, String commName, Long lastCommId); List<Map<String, Object>> byType(Integer categoryId, Long lastCommId); List<Map<String, Object>> type4(String commName, Long lastCommId); List<Map<String, Object>> forPut(List<Commoditys> list); @Override List<Map<String, Object>> selectHeight(Long lastCommId); @Override Long generateNewRoundTime(); @Override List<Map<String, Object>> selectNewestAnnounceComm(Long lastCommId); @Override List<Map> selectThePastAnnouncedCommList(Long commId); @Override String getContent(Long commodityId); @Override long getMaxRoundTime(); @Override List<CommodityTemplate> getNotKeepRoundTemplate(long roundNum); @Override Commodity getNextCommodity(Long id); @Override Commodity groundNext(Long id); @Override Commoditys getDetails(Long id); @Override Commoditys selectOnSellCommodities(Long id); @Override List<CommodityAmount> selectAmounts(Long orderId); }
|
@Test public void testSelectPaging() throws Exception { List<Map<String, Object>> list = service.selectPaging(1, "123", null); for (Map<String,Object> map : list){ System.out.println(map.get("commodityName")); } }
|
CommodityServiceImpl implements ICommodityService { public List<Map<String, Object>> type1(Integer categoryId, String commName, Long lastCommId) { List<Commoditys> list = commsMapper.selectByTypeAndName("%" + commName + "%", categoryId, Settings.COMMODITY_STATE_ON_SALE, lastCommId, Settings.PAGE_LOAD_SIZE_10); return forPut(list); } @Override boolean addCommodity(Commoditys commod); @Override boolean delete(Long id); @Override Commoditys selectByid(Long id); @Override List<Commoditys> selectTypeAll(String commodType); @Override int selectCount(Integer commodityTypeId); @Override List<Commoditys> selectAll(); @Override List<Map<String, Object>> selectByStyle(Integer type, Long lastCommId); @Override List<Map<String, Object>> selectOnLottery(Integer page); @Override List<Map<String, Object>> selectOneOnLottery(Long commId); @Override Map<String, Object> selectCommodity(User user, Long commodId); List<Map<String, Object>> listMap3(); List<String> listUrl(Long commodId); Map<String, Object> mapBefore(Commoditys comh); List<Map<String, Object>> listPartake(Long commodId); Map<String, Object> map1(Long userAccountId); Map<String, Object> map2(Long commodId, Long userAccountId); @Override List<Map<String, Object>> selectPaging(Integer categoryId, String commName, Long lastCommId); List<Map<String, Object>> type1(Integer categoryId, String commName, Long lastCommId); List<Map<String, Object>> byType(Integer categoryId, Long lastCommId); List<Map<String, Object>> type4(String commName, Long lastCommId); List<Map<String, Object>> forPut(List<Commoditys> list); @Override List<Map<String, Object>> selectHeight(Long lastCommId); @Override Long generateNewRoundTime(); @Override List<Map<String, Object>> selectNewestAnnounceComm(Long lastCommId); @Override List<Map> selectThePastAnnouncedCommList(Long commId); @Override String getContent(Long commodityId); @Override long getMaxRoundTime(); @Override List<CommodityTemplate> getNotKeepRoundTemplate(long roundNum); @Override Commodity getNextCommodity(Long id); @Override Commodity groundNext(Long id); @Override Commoditys getDetails(Long id); @Override Commoditys selectOnSellCommodities(Long id); @Override List<CommodityAmount> selectAmounts(Long orderId); }
|
@Test public void testType1() throws Exception { }
|
CommodityServiceImpl implements ICommodityService { public List<Map<String, Object>> byType(Integer categoryId, Long lastCommId) { List<Commoditys> list = commsMapper.selectByType(categoryId, Settings.COMMODITY_STATE_ON_SALE, lastCommId, Settings.PAGE_LOAD_SIZE_10); return forPut(list); } @Override boolean addCommodity(Commoditys commod); @Override boolean delete(Long id); @Override Commoditys selectByid(Long id); @Override List<Commoditys> selectTypeAll(String commodType); @Override int selectCount(Integer commodityTypeId); @Override List<Commoditys> selectAll(); @Override List<Map<String, Object>> selectByStyle(Integer type, Long lastCommId); @Override List<Map<String, Object>> selectOnLottery(Integer page); @Override List<Map<String, Object>> selectOneOnLottery(Long commId); @Override Map<String, Object> selectCommodity(User user, Long commodId); List<Map<String, Object>> listMap3(); List<String> listUrl(Long commodId); Map<String, Object> mapBefore(Commoditys comh); List<Map<String, Object>> listPartake(Long commodId); Map<String, Object> map1(Long userAccountId); Map<String, Object> map2(Long commodId, Long userAccountId); @Override List<Map<String, Object>> selectPaging(Integer categoryId, String commName, Long lastCommId); List<Map<String, Object>> type1(Integer categoryId, String commName, Long lastCommId); List<Map<String, Object>> byType(Integer categoryId, Long lastCommId); List<Map<String, Object>> type4(String commName, Long lastCommId); List<Map<String, Object>> forPut(List<Commoditys> list); @Override List<Map<String, Object>> selectHeight(Long lastCommId); @Override Long generateNewRoundTime(); @Override List<Map<String, Object>> selectNewestAnnounceComm(Long lastCommId); @Override List<Map> selectThePastAnnouncedCommList(Long commId); @Override String getContent(Long commodityId); @Override long getMaxRoundTime(); @Override List<CommodityTemplate> getNotKeepRoundTemplate(long roundNum); @Override Commodity getNextCommodity(Long id); @Override Commodity groundNext(Long id); @Override Commoditys getDetails(Long id); @Override Commoditys selectOnSellCommodities(Long id); @Override List<CommodityAmount> selectAmounts(Long orderId); }
|
@Test public void testByType() throws Exception { }
|
CommodityServiceImpl implements ICommodityService { public List<Map<String, Object>> type4(String commName, Long lastCommId) { List<Commoditys> list = commsMapper.selectByName("%" + commName + "%", Settings.COMMODITY_STATE_ON_SALE, lastCommId, Settings.PAGE_LOAD_SIZE_10); return forPut(list); } @Override boolean addCommodity(Commoditys commod); @Override boolean delete(Long id); @Override Commoditys selectByid(Long id); @Override List<Commoditys> selectTypeAll(String commodType); @Override int selectCount(Integer commodityTypeId); @Override List<Commoditys> selectAll(); @Override List<Map<String, Object>> selectByStyle(Integer type, Long lastCommId); @Override List<Map<String, Object>> selectOnLottery(Integer page); @Override List<Map<String, Object>> selectOneOnLottery(Long commId); @Override Map<String, Object> selectCommodity(User user, Long commodId); List<Map<String, Object>> listMap3(); List<String> listUrl(Long commodId); Map<String, Object> mapBefore(Commoditys comh); List<Map<String, Object>> listPartake(Long commodId); Map<String, Object> map1(Long userAccountId); Map<String, Object> map2(Long commodId, Long userAccountId); @Override List<Map<String, Object>> selectPaging(Integer categoryId, String commName, Long lastCommId); List<Map<String, Object>> type1(Integer categoryId, String commName, Long lastCommId); List<Map<String, Object>> byType(Integer categoryId, Long lastCommId); List<Map<String, Object>> type4(String commName, Long lastCommId); List<Map<String, Object>> forPut(List<Commoditys> list); @Override List<Map<String, Object>> selectHeight(Long lastCommId); @Override Long generateNewRoundTime(); @Override List<Map<String, Object>> selectNewestAnnounceComm(Long lastCommId); @Override List<Map> selectThePastAnnouncedCommList(Long commId); @Override String getContent(Long commodityId); @Override long getMaxRoundTime(); @Override List<CommodityTemplate> getNotKeepRoundTemplate(long roundNum); @Override Commodity getNextCommodity(Long id); @Override Commodity groundNext(Long id); @Override Commoditys getDetails(Long id); @Override Commoditys selectOnSellCommodities(Long id); @Override List<CommodityAmount> selectAmounts(Long orderId); }
|
@Test public void testType4() throws Exception { }
|
CommodityServiceImpl implements ICommodityService { public List<Map<String, Object>> forPut(List<Commoditys> list) { List<Map<String, Object>> listMap = new ArrayList<>(); for (Commoditys com : list) { Map<String, Object> map = new HashMap<>(); map.put("id", com.getId()); map.put("minNum", com.getMinimum()); map.put("typeId", com.getCommodityTypeId()); map.put("commodityName", com.getName()); map.put("totalNumber", com.getBuyTotalNumber()); map.put("currentNumber", com.getBuyTotalNumber() - com.getBuyCurrentNumber()); map.put("headerImg", com.getCoverImgUrl()); map.put("state", com.getStateId()); listMap.add(map); } return listMap; } @Override boolean addCommodity(Commoditys commod); @Override boolean delete(Long id); @Override Commoditys selectByid(Long id); @Override List<Commoditys> selectTypeAll(String commodType); @Override int selectCount(Integer commodityTypeId); @Override List<Commoditys> selectAll(); @Override List<Map<String, Object>> selectByStyle(Integer type, Long lastCommId); @Override List<Map<String, Object>> selectOnLottery(Integer page); @Override List<Map<String, Object>> selectOneOnLottery(Long commId); @Override Map<String, Object> selectCommodity(User user, Long commodId); List<Map<String, Object>> listMap3(); List<String> listUrl(Long commodId); Map<String, Object> mapBefore(Commoditys comh); List<Map<String, Object>> listPartake(Long commodId); Map<String, Object> map1(Long userAccountId); Map<String, Object> map2(Long commodId, Long userAccountId); @Override List<Map<String, Object>> selectPaging(Integer categoryId, String commName, Long lastCommId); List<Map<String, Object>> type1(Integer categoryId, String commName, Long lastCommId); List<Map<String, Object>> byType(Integer categoryId, Long lastCommId); List<Map<String, Object>> type4(String commName, Long lastCommId); List<Map<String, Object>> forPut(List<Commoditys> list); @Override List<Map<String, Object>> selectHeight(Long lastCommId); @Override Long generateNewRoundTime(); @Override List<Map<String, Object>> selectNewestAnnounceComm(Long lastCommId); @Override List<Map> selectThePastAnnouncedCommList(Long commId); @Override String getContent(Long commodityId); @Override long getMaxRoundTime(); @Override List<CommodityTemplate> getNotKeepRoundTemplate(long roundNum); @Override Commodity getNextCommodity(Long id); @Override Commodity groundNext(Long id); @Override Commoditys getDetails(Long id); @Override Commoditys selectOnSellCommodities(Long id); @Override List<CommodityAmount> selectAmounts(Long orderId); }
|
@Test public void testForPut() throws Exception { List<Map<String, Object>> list = service.selectOnLottery(1); System.out.println(list.size()); for (Map<String, Object> map : list){ System.out.println(map.get("roundTime")); } Assert.assertNotNull(list); }
|
CommodityHistoryServiceImpl implements ICommodityHistoryService { @Override public LotteryInfo selectLotteryInfo(Long commId) { return lotteryInfoMapper.selectByComId(commId); } @Override LotteryInfo selectLotteryInfo(Long commId); }
|
@Test public void testSelectLotteryInfo() throws Exception { LotteryInfo info = service.selectLotteryInfo(11l); }
|
ShoppingCartServiceImpl implements IShoppingCartService { @Override public boolean deleteCommodity(Long accountId, Long commId) { if (null == accountId || null == commId) return false; ShoppingCart shopping = new ShoppingCart(); shopping.setUserAccountId(accountId); shopping.setCommodityId(commId); return mapper.delete(mapper.selectOne(shopping)) > 0; } @Override boolean addCommodityToCart(Long accountId, Long commId, Integer count); @Override boolean deleteCommodity(Long accountId, Long commId); @Override boolean updateCommodity(Long accountId, Long commId, Integer count); @Override List<Map<String, Object>> selectByAccount(Long accountId); }
|
@Test public void testDeleteCommodity() throws Exception { }
|
CommodityExchangeServiceImpl implements ICommodityExchangeService { @Override public List<Map<String, Object>> selectByCommodityId(Long commId) { List<CommodityExchange> exchangeList = ceMapper.selectExcInfoByCommodityId(commId); List<Map<String, Object>> mapList = new ArrayList<>(); for (CommodityExchange commExc : exchangeList) { Map<String, Object> map = new HashMap<>(); map.put("id", commExc.getExchangeWayId()); map.put("exchangeWay", commExc.getEwName()); map.put("url", Settings.SERVER_URL_PATH + commExc.getEwUrl()); map.put("quota", 0); mapList.add(map); } return mapList; } @Override boolean addExchange(CommodityExchange exchange); @Override boolean deleteExchange(CommodityExchange exchange); @Override boolean updateExchange(CommodityExchange exchange); @Override List<Map<String, Object>> selectByCommodityId(Long commId); }
|
@Test public void testSelectByCommodityId() throws Exception { List<Map<String, Object>> list = service.selectByCommodityId(26l); for(Map<String, Object> map : list){ System.out.println(map.get("id")); System.out.println(map.get("exchangeWay")); System.out.println(map.get("url")); System.out.println(map.get("quota")); } }
|
ImagesServiceImpl implements ImagesService { @Override public boolean addImage(Images img) { int insert = imagesMapper.insert(img); if (insert > 0) { return true; } return false; } @Override boolean addImage(Images img); @Override boolean deleteImage(Long id); @Override List<Map<String, Object>> selectIcon(); @Override List<Map<String, Object>> selectAdvert(); @Override boolean update(Images img); @Override List<Map<String, Object>> selectEvent(); @Override List<String> selectWelcomeImg(); @Override List<String> selectnavigeteImg(); }
|
@Test public void testAddImage() throws Exception { Images i = new Images(); i.setImgGenre(1); i.setImgUrl("http: i.setDepict("高中奖率"); i.setState(1); boolean b = image.addImage(i); Assert.assertTrue(b); }
|
ImagesServiceImpl implements ImagesService { @Override public boolean deleteImage(Long id) { int i = imagesMapper.deleteByPrimaryKey(id); if (i > 0) { return true; } return false; } @Override boolean addImage(Images img); @Override boolean deleteImage(Long id); @Override List<Map<String, Object>> selectIcon(); @Override List<Map<String, Object>> selectAdvert(); @Override boolean update(Images img); @Override List<Map<String, Object>> selectEvent(); @Override List<String> selectWelcomeImg(); @Override List<String> selectnavigeteImg(); }
|
@Test public void testDeleteImage() throws Exception { boolean b = image.deleteImage(1l); Assert.assertTrue(b); }
|
ImagesServiceImpl implements ImagesService { @Override public List<Map<String, Object>> selectIcon() { List<Images> imagesList = imagesMapper.selectUsingImgs(1, 1); return dealImgInfo(imagesList); } @Override boolean addImage(Images img); @Override boolean deleteImage(Long id); @Override List<Map<String, Object>> selectIcon(); @Override List<Map<String, Object>> selectAdvert(); @Override boolean update(Images img); @Override List<Map<String, Object>> selectEvent(); @Override List<String> selectWelcomeImg(); @Override List<String> selectnavigeteImg(); }
|
@Test public void testSelectIcon() throws Exception { }
|
ImagesServiceImpl implements ImagesService { @Override public List<Map<String, Object>> selectAdvert() { Images i = new Images(); i.setImgGenre(2); i.setState(1); List<Images> imagesList = imagesMapper.select(i); return dealImgInfo(imagesList); } @Override boolean addImage(Images img); @Override boolean deleteImage(Long id); @Override List<Map<String, Object>> selectIcon(); @Override List<Map<String, Object>> selectAdvert(); @Override boolean update(Images img); @Override List<Map<String, Object>> selectEvent(); @Override List<String> selectWelcomeImg(); @Override List<String> selectnavigeteImg(); }
|
@Test public void testSelectAdvert() throws Exception { }
|
ImagesServiceImpl implements ImagesService { @Override public boolean update(Images img) { int i = imagesMapper.updateByPrimaryKeySelective(img); if (i > 0) { return true; } return false; } @Override boolean addImage(Images img); @Override boolean deleteImage(Long id); @Override List<Map<String, Object>> selectIcon(); @Override List<Map<String, Object>> selectAdvert(); @Override boolean update(Images img); @Override List<Map<String, Object>> selectEvent(); @Override List<String> selectWelcomeImg(); @Override List<String> selectnavigeteImg(); }
|
@Test public void testUpdate() throws Exception { Images i = new Images(); i.setId(1l); i.setImgGenre(2); boolean b = image.update(i); Assert.assertTrue(b); }
|
OrdersServiceImpl implements IOrdersService { @Override @Transactional(isolation = Isolation.READ_COMMITTED) public Long pay(Long accountId, Orders orders, List<CommodityAmount> commodityAmounts) { Long date = new Date().getTime(); orders.setUserAccountId(accountId); orders.setSubmitDate(date); mapper.insertUseGenerated(orders); for (CommodityAmount ca : commodityAmounts) { Commoditys currentCommodity = comMapper.selectByKey(ca.getCommodityId()); if(currentCommodity.getStateId() != Commodity.ON_SELL){ currentCommodity = commodityService.selectOnSellCommodities(ca.getCommodityId()); if(null == currentCommodity) throw new NullPointerException("未获取到商品"); } int remainingNum = currentCommodity.getBuyTotalNumber() - currentCommodity.getBuyCurrentNumber(); int buyNum = ca.getAmount(); if (buyNum > remainingNum) { Commodity nextCommodity = commodityService.getNextCommodity(currentCommodity.getId()); updateLuckCodes(accountId, nextCommodity.getId(), buyNum - remainingNum, orders); buyNum = remainingNum; } updateLuckCodes(accountId, currentCommodity.getId(), buyNum, orders); } ordersServiceImplAsync.payAsync(accountId, orders, commodityAmounts); return orders.getId(); } @Override @Transactional(isolation = Isolation.READ_COMMITTED) Long pay(Long accountId, Orders orders, List<CommodityAmount> commodityAmounts); @Transactional(isolation = Isolation.READ_COMMITTED) boolean updateLuckCodes(Long accountid, long commodityId, int buyNum, Orders orders); @Override List<Orders> selectByUserAccount(Long userAccount); @Override boolean deleteOder(Long id); @Override boolean update(Orders oders); @Override Map<String, Object> selectUsableRedPackets(Long accountId, Integer sum); @Override Map<String, Object> selectPaySuccess(Long accountId, Long orderId); List<String> luckCodes(Long accountId, Long commodityId, Long ordersId); }
|
@Test public void testPay() throws Exception { Long accountId = 10000L; Orders orders = new Orders(); orders.setUserAccountId(accountId); orders.setPayModeId(1); orders.setRedPacketId(0l); orders.setPrice(60); orders.setSubmitDate(new Date().getTime()); List<CommodityAmount> list = new ArrayList<>(); CommodityAmount commodityAmount = new CommodityAmount(); commodityAmount.setCommodityId(2L); commodityAmount.setAmount(50); list.add(commodityAmount); service.pay(accountId, orders, list); }
|
LuckNoticeServiceImpl implements ILuckNoticeService { @Override public Map<String,Object> addUserLuckNotice(Long commodityId) { Commodity commodity = comMapper.selectByKey(commodityId); LotteryInfo lotteryInfo = lotteryInfoMapper.selectByComId(commodityId); User user = userMapper.selectById(lotteryInfo.getUserAccountId()); Map<String,Object> map = new HashMap<>(); map.put("userName",user.getNickname()); map.put("buyNum",commodity.getBuyNumber()); map.put("endTime",commodity.getEndTime()); if(commodity.getStateId()!=1){ Commodity com = new Commodity(); com.setId(commodityId); com.setStateId(1); comMapper.updateByPrimaryKeySelective(com); return map; } else { return map; } } @Override Map<String,Object> addUserLuckNotice(Long commodityId); @Override boolean deleteUserLuckNotice(LuckNotice notice); @Override Map<String, Object> selectByCommodityId(Long commodityId); @Override boolean updateUserLuckNotice(LuckNotice notice); }
|
@Test public void testAddUserLuckNotice() throws Exception { }
|
LuckNoticeServiceImpl implements ILuckNoticeService { @Override public boolean deleteUserLuckNotice(LuckNotice notice) { return mapper.delete(notice)>0; } @Override Map<String,Object> addUserLuckNotice(Long commodityId); @Override boolean deleteUserLuckNotice(LuckNotice notice); @Override Map<String, Object> selectByCommodityId(Long commodityId); @Override boolean updateUserLuckNotice(LuckNotice notice); }
|
@Test public void testDeleteUserLuckNotice() throws Exception { }
|
LuckNoticeServiceImpl implements ILuckNoticeService { @Override public Map<String, Object> selectByCommodityId(Long commodityId) { return null; } @Override Map<String,Object> addUserLuckNotice(Long commodityId); @Override boolean deleteUserLuckNotice(LuckNotice notice); @Override Map<String, Object> selectByCommodityId(Long commodityId); @Override boolean updateUserLuckNotice(LuckNotice notice); }
|
@Test public void testSelectByCommodityId() throws Exception { }
|
ShoppingCartServiceImpl implements IShoppingCartService { @Override public boolean updateCommodity(Long accountId, Long commId, Integer count) { Commoditys commoditys = commodMapper.selectByPrimaryKey(commId); Integer state = commoditys.getStateId(); boolean can = commoditys.getBuyCurrentNumber() + count > commoditys.getBuyTotalNumber(); if (state == Settings.COMMODITY_STATE_ON_LOTTERY || state == Settings.COMMODITY_STATE_HAS_LOTTERY || can) return false; ShoppingCart shopping = new ShoppingCart(); shopping.setUserAccountId(accountId); shopping.setCommodityId(commId); ShoppingCart shoppingCart = mapper.selectOne(shopping); shoppingCart.setNumber(count); return mapper.updateByPrimaryKeySelective(shoppingCart) > 0; } @Override boolean addCommodityToCart(Long accountId, Long commId, Integer count); @Override boolean deleteCommodity(Long accountId, Long commId); @Override boolean updateCommodity(Long accountId, Long commId, Integer count); @Override List<Map<String, Object>> selectByAccount(Long accountId); }
|
@Test public void testUpdateCommodity() throws Exception { }
|
LuckNoticeServiceImpl implements ILuckNoticeService { @Override public boolean updateUserLuckNotice(LuckNotice notice) { Example e = new Example(LuckNotice.class); Example.Criteria criteria = e.createCriteria(); criteria.andEqualTo("id",notice.getId()); e.or(criteria); return mapper.updateByExampleSelective(notice,e)>0; } @Override Map<String,Object> addUserLuckNotice(Long commodityId); @Override boolean deleteUserLuckNotice(LuckNotice notice); @Override Map<String, Object> selectByCommodityId(Long commodityId); @Override boolean updateUserLuckNotice(LuckNotice notice); }
|
@Test public void testUpdateUserLuckNotice() throws Exception { }
|
LotteryUtils { @Async public static LotteryInfo raffle(NotificationPrizeMapper npMapper,CommodityMapper commMapper, CommoditysMapper commsMapper, OrdersMapper ordersMapper, LuckCodeTemplateMapper codesTemplateMapper, LuckCodesMapper luckCodesMapper, LotteryInfoMapper lotteryInfoMapper, UserMapper userMapper, Commoditys commodity) { Calendar calendar = Calendar.getInstance(); List<Orders> orderses = ordersMapper.selectByBuyDateDesc(); LotteryInfo lotteryInfo = new LotteryInfo(); long sumDate = 0; String subTime; JSONArray array = new JSONArray(); for (Orders orders : orderses) { Long buyDate = orders.getSubmitDate(); calendar.setTimeInMillis(buyDate); User user = userMapper.selectById(orders.getUserAccountId()); String date = formatDate(buyDate); subTime = substringTime(date); sumDate += Integer.valueOf(subTime); array.add(date + " " + subTime + " : " + user.getNickname()); } lotteryInfo.setCommodityId(commodity.getId()); lotteryInfo.setBuyNum(commodity.getBuyTotalNumber()); lotteryInfo.setLotteryInfo(array.toString()); lotteryInfo.setSumDate(sumDate); long lotteryId = (sumDate % commodity.getBuyTotalNumber()) + 10000001; lotteryInfo.setLotteryId(lotteryId); LuckCodeTemplate template = codesTemplateMapper.selectByCode(lotteryId + ""); LuckCodes codes = luckCodesMapper.selectBytemplate(template.getId(), commodity.getId()); lotteryInfo.setUserAccountId(codes.getUserAccountId()); UpdateTiming update = new UpdateTiming(npMapper,userMapper,commMapper, commsMapper, codesTemplateMapper, luckCodesMapper, lotteryInfoMapper, lotteryInfo); long endTime = commodity.getSellOutTime() + Settings.LOTTERY_ANNOUNCE_TIME_INTERVAL; endTime = endTime - System.currentTimeMillis(); endTime = endTime / 1000; System.out.println("延时--------------------->" + endTime+"秒开奖！"); DelayTask.execute(update, (int) endTime); return lotteryInfo; } @Async static LotteryInfo raffle(NotificationPrizeMapper npMapper,CommodityMapper commMapper, CommoditysMapper commsMapper, OrdersMapper ordersMapper, LuckCodeTemplateMapper codesTemplateMapper, LuckCodesMapper luckCodesMapper, LotteryInfoMapper lotteryInfoMapper, UserMapper userMapper, Commoditys commodity); }
|
@Test public void testRaffle() throws Exception { }
|
OrdersController extends BaseController { @ResponseBody @ApiOperation("订单支付成功返回客户端信息接口") @RequestMapping(value = "/api/v1/user/orders/suc", method = {RequestMethod.POST, RequestMethod.GET}) public JSONObject queryOrderSuccess(@RequestParam("ordersId") Long ordersId) { Map<String, Object> mapInfo = ordersService.selectPaySuccess(getUserId(), ordersId); return success(mapInfo); } @ResponseBody @ApiOperation("用户提交订单") @RequestMapping(value = "/api/v1/user/orders/sub", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject addOrders(@RequestBody OrderFormData orderFormData); @ResponseBody @ApiOperation("用户查看订单信息（tip:未使用、未实现功能）") @RequestMapping(value = "/api/v1/user/orders/info", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject queryOrder(@RequestParam("orderid") Long orderid); @ResponseBody @ApiOperation("订单支付成功返回客户端信息接口") @RequestMapping(value = "/api/v1/user/orders/suc", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject queryOrderSuccess(@RequestParam("ordersId") Long ordersId); @ResponseBody @RequestMapping(value = "/api/v1/user/orders/show", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject queryAllUserOrders(); @ResponseBody @RequestMapping(value = "/api/v1/user/orders/show/code", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject queryOrderCodes(@ApiParam("订单ID") @RequestParam("orderId") Long orderId) {; }
|
@Test public void testQueryOrderSuccess() throws Exception { Map<String, Object> map = new HashMap<>(); Orders orders = new Orders(); orders.setPayModeId(1); orders.setPrice(10); orders.setSubmitDate(new Date().getTime()); map.put("order", orders); List<CommodityAmount> list = new ArrayList<>(); CommodityAmount ca = new CommodityAmount(); ca.setCommodityId(46L); ca.setAmount(1); list.add(ca); map.put("ca", list); String s = "{\"ca\":\"[{\"commodityId\":4,\"amount\":1},{\"commodityId\":8,\"amount\":2}]}"; System.out.println(JSON.toJSONString(map)); post("/api/v1/user/orders/suc", JSON.toJSONString(map)); }
|
OrdersController extends BaseController { @ResponseBody @ApiOperation("用户提交订单") @RequestMapping(value = "/api/v1/user/orders/sub", method = {RequestMethod.POST, RequestMethod.GET}) public JSONObject addOrders(@RequestBody OrderFormData orderFormData) { return success("操作成功", ordersService.pay(getUserId(), orderFormData.getOrder(), orderFormData.getCaList())); } @ResponseBody @ApiOperation("用户提交订单") @RequestMapping(value = "/api/v1/user/orders/sub", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject addOrders(@RequestBody OrderFormData orderFormData); @ResponseBody @ApiOperation("用户查看订单信息（tip:未使用、未实现功能）") @RequestMapping(value = "/api/v1/user/orders/info", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject queryOrder(@RequestParam("orderid") Long orderid); @ResponseBody @ApiOperation("订单支付成功返回客户端信息接口") @RequestMapping(value = "/api/v1/user/orders/suc", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject queryOrderSuccess(@RequestParam("ordersId") Long ordersId); @ResponseBody @RequestMapping(value = "/api/v1/user/orders/show", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject queryAllUserOrders(); @ResponseBody @RequestMapping(value = "/api/v1/user/orders/show/code", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject queryOrderCodes(@ApiParam("订单ID") @RequestParam("orderId") Long orderId) {; }
|
@Test public void testAddOrders() throws Exception { Map<String, Object> map = new HashMap<>(); Orders order = new Orders(); order.setUserAccountId(10000L); order.setPrice(1); order.setPayModeId(1); order.setSubmitDate(new Date().getTime()); map.put("order", order); List<CommodityAmount> list = new ArrayList<>(); CommodityAmount ca = new CommodityAmount(); ca.setAmount(1); ca.setCommodityId(4L); list.add(ca); map.put("ca", list); post("/api/v1/user/orders/sub", JSON.toJSONString(map)); }
|
OrdersController extends BaseController { @ResponseBody @ApiOperation("用户查看订单信息（tip:未使用、未实现功能）") @RequestMapping(value = "/api/v1/user/orders/info", method = {RequestMethod.POST, RequestMethod.GET}) public JSONObject queryOrder(@RequestParam("orderid") Long orderid) { Orders order = new Orders(); return success(order); } @ResponseBody @ApiOperation("用户提交订单") @RequestMapping(value = "/api/v1/user/orders/sub", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject addOrders(@RequestBody OrderFormData orderFormData); @ResponseBody @ApiOperation("用户查看订单信息（tip:未使用、未实现功能）") @RequestMapping(value = "/api/v1/user/orders/info", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject queryOrder(@RequestParam("orderid") Long orderid); @ResponseBody @ApiOperation("订单支付成功返回客户端信息接口") @RequestMapping(value = "/api/v1/user/orders/suc", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject queryOrderSuccess(@RequestParam("ordersId") Long ordersId); @ResponseBody @RequestMapping(value = "/api/v1/user/orders/show", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject queryAllUserOrders(); @ResponseBody @RequestMapping(value = "/api/v1/user/orders/show/code", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject queryOrderCodes(@ApiParam("订单ID") @RequestParam("orderId") Long orderId) {; }
|
@Test public void testQueryOrder() throws Exception { }
|
OrdersController extends BaseController { @ResponseBody @RequestMapping(value = "/api/v1/user/orders/show", method = {RequestMethod.POST, RequestMethod.GET}) public JSONObject queryAllUserOrders() { List<Orders> olist = ordersService.selectByUserAccount(getUserId()); return success(olist); } @ResponseBody @ApiOperation("用户提交订单") @RequestMapping(value = "/api/v1/user/orders/sub", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject addOrders(@RequestBody OrderFormData orderFormData); @ResponseBody @ApiOperation("用户查看订单信息（tip:未使用、未实现功能）") @RequestMapping(value = "/api/v1/user/orders/info", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject queryOrder(@RequestParam("orderid") Long orderid); @ResponseBody @ApiOperation("订单支付成功返回客户端信息接口") @RequestMapping(value = "/api/v1/user/orders/suc", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject queryOrderSuccess(@RequestParam("ordersId") Long ordersId); @ResponseBody @RequestMapping(value = "/api/v1/user/orders/show", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject queryAllUserOrders(); @ResponseBody @RequestMapping(value = "/api/v1/user/orders/show/code", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject queryOrderCodes(@ApiParam("订单ID") @RequestParam("orderId") Long orderId) {; }
|
@Test public void testQueryAllUserOrders() throws Exception { }
|
DeliveryAddressController extends BaseController { @RequestMapping(value = "/api/v1/user/address/add", method = {RequestMethod.POST, RequestMethod.GET}) public JSONObject addAddress(@RequestBody DeliveryAddress address) { boolean status = addressService.addDa(getUserId(),address); return response(status, "最多添加3条收货地址"); } @RequestMapping(value = "/api/v1/user/address/add", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject addAddress(@RequestBody DeliveryAddress address); @RequestMapping(value = "/api/v1/user/address/del", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject deleteAddress(@RequestParam("addressId") Long addressId); @ApiOperation("修改收货地址（tip；未使用！）") @RequestMapping(value = "/api/v1/user/address/up", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject updateAddress(@RequestBody DeliveryAddress address); @ApiOperation("查看收货地址信息") @RequestMapping(value = "/api/v1/user/address/show", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject queryAddress(); }
|
@Test public void testAddAddress() throws Exception { DeliveryAddress da = new DeliveryAddress(); da.setUserId(1000l); da.setAddress("qwert"); post("/user/address/add", JSON.toJSONString(da)); }
|
DeliveryAddressController extends BaseController { @RequestMapping(value = "/api/v1/user/address/del", method = {RequestMethod.POST, RequestMethod.GET}) public JSONObject deleteAddress(@RequestParam("addressId") Long addressId) { boolean status = addressService.deleteDa(addressId); return response(status); } @RequestMapping(value = "/api/v1/user/address/add", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject addAddress(@RequestBody DeliveryAddress address); @RequestMapping(value = "/api/v1/user/address/del", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject deleteAddress(@RequestParam("addressId") Long addressId); @ApiOperation("修改收货地址（tip；未使用！）") @RequestMapping(value = "/api/v1/user/address/up", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject updateAddress(@RequestBody DeliveryAddress address); @ApiOperation("查看收货地址信息") @RequestMapping(value = "/api/v1/user/address/show", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject queryAddress(); }
|
@Test public void testDeleteAddress() throws Exception { String addrid = "addrid=1243"; post("/user/address/del", addrid); }
|
DeliveryAddressController extends BaseController { @ApiOperation("修改收货地址（tip；未使用！）") @RequestMapping(value = "/api/v1/user/address/up", method = {RequestMethod.POST, RequestMethod.GET}) public JSONObject updateAddress(@RequestBody DeliveryAddress address) { boolean status = addressService.updateDa(getUserId(),address); return response(status); } @RequestMapping(value = "/api/v1/user/address/add", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject addAddress(@RequestBody DeliveryAddress address); @RequestMapping(value = "/api/v1/user/address/del", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject deleteAddress(@RequestParam("addressId") Long addressId); @ApiOperation("修改收货地址（tip；未使用！）") @RequestMapping(value = "/api/v1/user/address/up", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject updateAddress(@RequestBody DeliveryAddress address); @ApiOperation("查看收货地址信息") @RequestMapping(value = "/api/v1/user/address/show", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject queryAddress(); }
|
@Test public void testUpdateAddress() throws Exception { }
|
DeliveryAddressController extends BaseController { @ApiOperation("查看收货地址信息") @RequestMapping(value = "/api/v1/user/address/show", method = {RequestMethod.POST, RequestMethod.GET}) public JSONObject queryAddress() { List<Map<String, Object>> mapList = addressService.selectByAccountId(getUserId()); return success(mapList); } @RequestMapping(value = "/api/v1/user/address/add", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject addAddress(@RequestBody DeliveryAddress address); @RequestMapping(value = "/api/v1/user/address/del", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject deleteAddress(@RequestParam("addressId") Long addressId); @ApiOperation("修改收货地址（tip；未使用！）") @RequestMapping(value = "/api/v1/user/address/up", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject updateAddress(@RequestBody DeliveryAddress address); @ApiOperation("查看收货地址信息") @RequestMapping(value = "/api/v1/user/address/show", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject queryAddress(); }
|
@Test public void testQueryAddress() throws Exception { }
|
ShoppingCartServiceImpl implements IShoppingCartService { @Override public List<Map<String, Object>> selectByAccount(Long accountId) { List<Map<String, Object>> mapList = new ArrayList<>(); ShoppingCart shopping = new ShoppingCart(); shopping.setUserAccountId(accountId); List<ShoppingCart> list = mapper.select(shopping); for (ShoppingCart sc : list) { Map<String, Object> map = new HashMap<>(); Commoditys key = commodMapper.selectByPrimaryKey(sc.getCommodityId()); map.put("commodityName", key.getName()); map.put("buyCurrentNumber", key.getBuyCurrentNumber()); map.put("buyTotalNumber", key.getBuyTotalNumber()); map.put("commodityId", key.getId()); map.put("coverImgUrl", key.getCoverImgUrl()); map.put("payNumber", sc.getNumber()); mapList.add(map); } return mapList; } @Override boolean addCommodityToCart(Long accountId, Long commId, Integer count); @Override boolean deleteCommodity(Long accountId, Long commId); @Override boolean updateCommodity(Long accountId, Long commId, Integer count); @Override List<Map<String, Object>> selectByAccount(Long accountId); }
|
@Test public void testSelectByAccount() throws Exception { List<Map<String, Object>> mapList = service.selectByAccount(2l); for (Map<String, Object> map: mapList){ System.out.println(map.get("commodityName")); } }
|
CommodityExchangeController extends BaseController { @ApiOperation("查询商品兑换方式") @RequestMapping(value = "/api/v1/user/commodity/commexchways", method = {RequestMethod.POST, RequestMethod.GET}) public JSONObject queryCommExchangeWays(@ApiParam("商品Id") @RequestParam("commId") Long commId) { return success(ceService.selectByCommodityId(commId)); } @ApiOperation("查询商品兑换方式") @RequestMapping(value = "/api/v1/user/commodity/commexchways", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject queryCommExchangeWays(@ApiParam("商品Id") @RequestParam("commId") Long commId) {; @ApiOperation("兑换现金") @RequestMapping(value = "/api/v1/user/commodity/exchange/temp3", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject exchangeToCash(@ApiParam("商品Id") @RequestParam("commId") Long commId, @ApiParam("平台名称（例：支付宝平台）") @RequestParam("TPName") String TPName, @ApiParam("平台账号") @RequestParam("TPAccount") String TPAccount) {; @ApiOperation("兑换闪币") @RequestMapping(value = "/api/v1/user/commodity/exchange/temp4", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject exchangeToGold(@ApiParam("商品Id") @RequestParam("commId") Long commId) {; @ApiOperation("兑换充值卡") @RequestMapping(value = "/api/v1/user/commodity/exchange/rcard/temp1", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject exchangeToRechargeCardTemp1(@ApiParam("商品Id") @RequestParam("commId") Long commId) {; @ApiOperation("查看充值卡卡密") @RequestMapping(value = "/api/v1/user/commodity/exchange/rcard/show/code", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject exchangeToRechargeCard(@ApiParam("卡号") @RequestParam("code") String code) {; @ApiOperation("可兑换充值卡方式详情") @RequestMapping(value = "/api/v1/user/commodity/exchange/rcard/show", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject queryExchangeToRechargeCard(@ApiParam("商品Id") @RequestParam("commId") Long commId) {; @ApiOperation("充值卡兑换流程详情") @RequestMapping(value = "/api/v1/user/commodity/exchange/rcard/info", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject queryExchangeToRechargeCardInfo(@ApiParam("商品Id") @RequestParam("commId") Long commId) {; @ApiOperation("快递收货") @RequestMapping(value = "/api/v1/user/commodity/exchange/temp2", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject exchangeToExpress(@ApiParam("商品Id") @RequestParam("commId") Long commId, @ApiParam("注册用户地址Id") @RequestParam("addressId") Long addressId) {; @ApiOperation("到店领取") @RequestMapping(value = "/api/v1/user/commodity/exchange/temp5", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject exchangeToLocale(@ApiParam("商品Id") @RequestParam("commId") Long commId) {; }
|
@Test public void testQueryCommExchangeWays() throws Exception { post("/api/v1/user/commodity/commexchways?commId=23", "commId="+23); }
|
CommodityExchangeController extends BaseController { @ApiOperation("兑换现金") @RequestMapping(value = "/api/v1/user/commodity/exchange/temp3", method = {RequestMethod.POST, RequestMethod.GET}) public JSONObject exchangeToCash(@ApiParam("商品Id") @RequestParam("commId") Long commId, @ApiParam("平台名称（例：支付宝平台）") @RequestParam("TPName") String TPName, @ApiParam("平台账号") @RequestParam("TPAccount") String TPAccount) { return success(emService.exchangeToCash(TPName, TPAccount, commId, getUserId())); } @ApiOperation("查询商品兑换方式") @RequestMapping(value = "/api/v1/user/commodity/commexchways", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject queryCommExchangeWays(@ApiParam("商品Id") @RequestParam("commId") Long commId) {; @ApiOperation("兑换现金") @RequestMapping(value = "/api/v1/user/commodity/exchange/temp3", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject exchangeToCash(@ApiParam("商品Id") @RequestParam("commId") Long commId, @ApiParam("平台名称（例：支付宝平台）") @RequestParam("TPName") String TPName, @ApiParam("平台账号") @RequestParam("TPAccount") String TPAccount) {; @ApiOperation("兑换闪币") @RequestMapping(value = "/api/v1/user/commodity/exchange/temp4", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject exchangeToGold(@ApiParam("商品Id") @RequestParam("commId") Long commId) {; @ApiOperation("兑换充值卡") @RequestMapping(value = "/api/v1/user/commodity/exchange/rcard/temp1", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject exchangeToRechargeCardTemp1(@ApiParam("商品Id") @RequestParam("commId") Long commId) {; @ApiOperation("查看充值卡卡密") @RequestMapping(value = "/api/v1/user/commodity/exchange/rcard/show/code", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject exchangeToRechargeCard(@ApiParam("卡号") @RequestParam("code") String code) {; @ApiOperation("可兑换充值卡方式详情") @RequestMapping(value = "/api/v1/user/commodity/exchange/rcard/show", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject queryExchangeToRechargeCard(@ApiParam("商品Id") @RequestParam("commId") Long commId) {; @ApiOperation("充值卡兑换流程详情") @RequestMapping(value = "/api/v1/user/commodity/exchange/rcard/info", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject queryExchangeToRechargeCardInfo(@ApiParam("商品Id") @RequestParam("commId") Long commId) {; @ApiOperation("快递收货") @RequestMapping(value = "/api/v1/user/commodity/exchange/temp2", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject exchangeToExpress(@ApiParam("商品Id") @RequestParam("commId") Long commId, @ApiParam("注册用户地址Id") @RequestParam("addressId") Long addressId) {; @ApiOperation("到店领取") @RequestMapping(value = "/api/v1/user/commodity/exchange/temp5", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject exchangeToLocale(@ApiParam("商品Id") @RequestParam("commId") Long commId) {; }
|
@Test public void testExchangeToCash() throws Exception { }
|
CommodityExchangeController extends BaseController { @ApiOperation("兑换闪币") @RequestMapping(value = "/api/v1/user/commodity/exchange/temp4", method = {RequestMethod.POST, RequestMethod.GET}) public JSONObject exchangeToGold(@ApiParam("商品Id") @RequestParam("commId") Long commId) { return success(emService.temp4(getUserId(), commId)); } @ApiOperation("查询商品兑换方式") @RequestMapping(value = "/api/v1/user/commodity/commexchways", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject queryCommExchangeWays(@ApiParam("商品Id") @RequestParam("commId") Long commId) {; @ApiOperation("兑换现金") @RequestMapping(value = "/api/v1/user/commodity/exchange/temp3", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject exchangeToCash(@ApiParam("商品Id") @RequestParam("commId") Long commId, @ApiParam("平台名称（例：支付宝平台）") @RequestParam("TPName") String TPName, @ApiParam("平台账号") @RequestParam("TPAccount") String TPAccount) {; @ApiOperation("兑换闪币") @RequestMapping(value = "/api/v1/user/commodity/exchange/temp4", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject exchangeToGold(@ApiParam("商品Id") @RequestParam("commId") Long commId) {; @ApiOperation("兑换充值卡") @RequestMapping(value = "/api/v1/user/commodity/exchange/rcard/temp1", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject exchangeToRechargeCardTemp1(@ApiParam("商品Id") @RequestParam("commId") Long commId) {; @ApiOperation("查看充值卡卡密") @RequestMapping(value = "/api/v1/user/commodity/exchange/rcard/show/code", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject exchangeToRechargeCard(@ApiParam("卡号") @RequestParam("code") String code) {; @ApiOperation("可兑换充值卡方式详情") @RequestMapping(value = "/api/v1/user/commodity/exchange/rcard/show", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject queryExchangeToRechargeCard(@ApiParam("商品Id") @RequestParam("commId") Long commId) {; @ApiOperation("充值卡兑换流程详情") @RequestMapping(value = "/api/v1/user/commodity/exchange/rcard/info", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject queryExchangeToRechargeCardInfo(@ApiParam("商品Id") @RequestParam("commId") Long commId) {; @ApiOperation("快递收货") @RequestMapping(value = "/api/v1/user/commodity/exchange/temp2", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject exchangeToExpress(@ApiParam("商品Id") @RequestParam("commId") Long commId, @ApiParam("注册用户地址Id") @RequestParam("addressId") Long addressId) {; @ApiOperation("到店领取") @RequestMapping(value = "/api/v1/user/commodity/exchange/temp5", method = {RequestMethod.POST, RequestMethod.GET}) JSONObject exchangeToLocale(@ApiParam("商品Id") @RequestParam("commId") Long commId) {; }
|
@Test public void testExchangeToGold() throws Exception { }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.