This repository has been archived by the owner on Nov 6, 2023. It is now read-only.
-
Notifications
You must be signed in to change notification settings - Fork 1
/
HomeController.java
201 lines (170 loc) · 7.36 KB
/
HomeController.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
package eu.xenit.alfred.initializr.web;
import java.beans.PropertyDescriptor;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import javax.servlet.http.HttpServletRequest;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.JsonNodeFactory;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.samskivert.mustache.Mustache;
import io.spring.initializr.metadata.Dependency;
import io.spring.initializr.metadata.DependencyGroup;
import io.spring.initializr.metadata.InitializrMetadata;
import io.spring.initializr.metadata.InitializrMetadataProvider;
import io.spring.initializr.metadata.TypeCapability;
import org.springframework.beans.BeanWrapperImpl;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.util.CollectionUtils;
import org.springframework.util.DigestUtils;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.resource.ResourceUrlProvider;
import org.springframework.web.servlet.support.ServletUriComponentsBuilder;
/**
* UI specific controller providing dedicated endpoints for the Web UI.
*
* @author Stephane Nicoll
*/
@Controller
public class HomeController {
protected final InitializrMetadataProvider metadataProvider;
protected final ResourceUrlProvider resourceUrlProvider;
private Boolean forceSsl;
private final Function<String, String> linkTo;
public HomeController(InitializrMetadataProvider metadataProvider,
ResourceUrlProvider resourceUrlProvider) {
this.metadataProvider = metadataProvider;
this.resourceUrlProvider = resourceUrlProvider;
this.linkTo = (link) -> {
String result = resourceUrlProvider.getForLookupPath(link);
return (result != null) ? result : link;
};
}
@ModelAttribute("linkTo")
public Mustache.Lambda linkTo() {
return (frag, out) -> out.write(this.linkTo.apply(frag.execute()));
}
@GetMapping(path = "/", produces = "text/html")
public String home(HttpServletRequest request, Map<String, Object> model) {
if (isForceSsl() && !request.isSecure()) {
String securedUrl = ServletUriComponentsBuilder.fromCurrentRequest()
.scheme("https").build().toUriString();
return "redirect:" + securedUrl;
}
renderHome(model);
return "home";
}
/**
* Render the home page with the specified template.
* @param model the model data
*/
protected void renderHome(Map<String, Object> model) {
InitializrMetadata metadata = this.metadataProvider.get();
model.put("serviceUrl", generateAppUrl());
BeanWrapperImpl wrapper = new BeanWrapperImpl(metadata);
for (PropertyDescriptor descriptor : wrapper.getPropertyDescriptors()) {
if ("types".equals(descriptor.getName())) {
model.put("types", removeTypes(metadata.getTypes()));
}
else {
model.put(descriptor.getName(),
wrapper.getPropertyValue(descriptor.getName()));
}
}
// Google analytics support
model.put("trackingCode",
metadata.getConfiguration().getEnv().getGoogleAnalyticsTrackingCode());
}
/**
* Generate a full URL of the service, mostly for use in templates.
* @return the app URL
* @see io.spring.initializr.metadata.InitializrConfiguration.Env#isForceSsl()
*/
protected String generateAppUrl() {
ServletUriComponentsBuilder builder = ServletUriComponentsBuilder
.fromCurrentServletMapping();
if (isForceSsl()) {
builder.scheme("https");
}
return builder.build().toString();
}
private TypeCapability removeTypes(TypeCapability types) {
TypeCapability result = new TypeCapability();
result.setDescription(types.getDescription());
result.setTitle(types.getTitle());
result.getContent().addAll(types.getContent());
// Only keep module type
result.getContent().removeIf((t) -> !"module".equals(t.getTags().get("format")));
return result;
}
private boolean isForceSsl() {
if (this.forceSsl == null) {
this.forceSsl = this.metadataProvider.get().getConfiguration().getEnv()
.isForceSsl();
}
return this.forceSsl;
}
@GetMapping(path = "/ui/dependencies", produces = "application/json")
@ResponseBody
public ResponseEntity<String> dependencies() {
List<DependencyGroup> dependencyGroups = this.metadataProvider.get()
.getDependencies().getContent();
List<DependencyItem> content = new ArrayList<>();
dependencyGroups
.forEach((group) -> group.getContent().forEach((dependency) -> content
.add(new DependencyItem(group.getName(), dependency))));
String json = writeDependencies(content);
return ResponseEntity.ok().contentType(MediaType.APPLICATION_JSON)
.eTag(createUniqueId(json)).body(json);
}
private static String writeDependencies(List<DependencyItem> items) {
ObjectNode json = JsonNodeFactory.instance.objectNode();
ArrayNode maps = JsonNodeFactory.instance.arrayNode();
items.forEach((dependency) -> maps.add(mapDependency(dependency)));
json.set("dependencies", maps);
return json.toString();
}
private static ObjectNode mapDependency(DependencyItem item) {
ObjectNode node = JsonNodeFactory.instance.objectNode();
Dependency dependency = item.dependency;
node.put("id", dependency.getId());
node.put("name", dependency.getName());
node.put("group", item.group);
node.put("weight", dependency.getWeight());
if (dependency.getDescription() != null) {
node.put("description", dependency.getDescription());
}
if (dependency.getCompatibilityRange() != null) {
node.put("compatibilityRange", dependency.getCompatibilityRange());
node.put("versionRequirement", dependency.getVersionRequirement());
}
if (!CollectionUtils.isEmpty(dependency.getKeywords())
|| !CollectionUtils.isEmpty(dependency.getAliases())) {
List<String> all = new ArrayList<>(dependency.getKeywords());
all.addAll(dependency.getAliases());
node.put("keywords", StringUtils.collectionToCommaDelimitedString(all));
}
return node;
}
private String createUniqueId(String content) {
StringBuilder builder = new StringBuilder();
DigestUtils.appendMd5DigestAsHex(content.getBytes(StandardCharsets.UTF_8),
builder);
return builder.toString();
}
private static class DependencyItem {
private final String group;
private final Dependency dependency;
DependencyItem(String group, Dependency dependency) {
this.group = group;
this.dependency = dependency;
}
}
}