feat: complete reverse engineering, standard Maven structure, detailed code annotations and IoT-M platform architecture

This commit is contained in:
rick committed 2026-11-16 14:35:53 +08:00
1 parent e8dc09fb3c
commit cd6a4c70e7
3045 files changed
+566733 -1

No files matched your search

@@ -0,0 +1,837 @@
package com.midm.service.org;
import com.google.api.client.util.Strings;
import com.google.common.base.Joiner;
import com.google.gson.JsonObject;
import com.midm.constant.LocaleConst;
import com.midm.model.org.Site;
import com.midm.model.org.SiteInfo;
import com.midm.model.org.User;
import com.midm.model.org.UserGroup;
import com.midm.model.org.UserToken;
import com.midm.security.UserPrincipal;
import com.midm.service.BaseService;
import com.midm.service.EmailService;
import com.midm.service.device.DeviceService;
import com.midm.service.log.LogService;
import com.midm.service.system.SettingsService;
import com.mitac.cell.db.DbObject;
import com.mitac.cell.db.util.McDbUtils;
import com.mitac.cell.db.util.McMongoUtils;
import com.mitac.cell.io.McFile;
import com.mitac.cell.utils.McEmailUtils;
import com.mitac.cell.utils.McJsonUtils;
import com.mitac.cell.utils.McStringUtils;
import com.mitac.cell.utils.McUuidUtils;
import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import java.util.regex.Pattern;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.bson.Document;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.domain.Sort.Direction;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Field;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import org.springframework.scheduling.annotation.Async;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
@Service
public class UserService extends BaseService {
@Autowired
private SiteService siteService;
@Autowired
private PasswordEncoder passwordEncoder;
@Autowired
@Lazy
private EmailService emailService;
@Autowired
private SettingsService settingsService;
@Autowired
private LogService logService;
@Autowired
private DeviceService deviceService;
private static boolean hasUser = false;
public boolean hasUser() {
if (!hasUser) {
hasUser = this.count(User.class) > 0L;
}
return hasUser;
}
public User save(User user) {
if (user != null && !Strings.isNullOrEmpty(user.getEmail())) {
user.setUpdated();
user = (User)this.saveDocument(user);
return user;
} else {
return null;
}
}
public void enableUsers(UUID siteUuid, List userUuids, boolean enabled) {
Query query = Query.query(Criteria.where("_id").in(userUuids).and("sites.siteUuid").is(siteUuid));
Update update = Update.update("sites.$.enabled", enabled);
this.mongoTemplate.updateMulti(query, update, User.class);
}
public List saveUsers(List users) {
List<User> savedUsers = new ArrayList();
for(User user : users) {
User savedUser = this.save(user);
savedUsers.add(savedUser);
}
return savedUsers;
}
public UpdateResult changePassword(User user, String newPassword) {
user.setPassword(this.passwordEncoder.encode(newPassword));
Update update = Update.update("password", user.getPassword()).set("updated", new Date());
UpdateResult result = this.mongoTemplate.updateFirst(this.queryById(user.getUuid()), update, User.class);
this.deleteToken(user, 'P');
return result;
}
public User register(HttpServletRequest request, HttpServletResponse response, User user) {
String password = user.getPassword();
user.init();
user.encodePassword(this.passwordEncoder);
user = (User)this.saveDocument(user);
if (this.count(User.class) == 1L) {
this.settingsService.save("meta.startedFrom", new Date());
}
user.setPassword(password);
this.emailService.sendActivatedNotification(request, response, user);
return user;
}
public void requestResetPassword(HttpServletRequest request, HttpServletResponse response, User user) {
UserToken token = new UserToken(user, 'P', 1800000L);
token = (UserToken)this.saveDocument(token);
this.emailService.sendPasswordResetRequest(request, response, user, token.getTokenUuid());
}
public boolean exists(User account) {
Query query = Query.query(Criteria.where("email").is(account.getEmail()));
return this.mongoTemplate.count(query, User.class) > 0L;
}
public UpdateResult saveSite(User user) {
Update update = Update.update("sites", user.getSites());
return this.mongoTemplate.updateFirst(this.queryById(user.getUuid()), update, User.class);
}
public UpdateResult addSite(User user, SiteInfo siteInfo) {
Update update = (new Update()).push("sites", siteInfo);
return this.mongoTemplate.updateFirst(this.queryById(user.getUuid()), update, User.class);
}
public UpdateResult deleteSite(User user, UUID siteUuid) {
if (siteUuid == null) {
return null;
} else {
if (user != null) {
this.deviceService.updateDeviceOwner(siteUuid, user, false);
}
Criteria criteria = user == null ? new Criteria() : Criteria.where("_id").is(user.getUuid());
Update update = new Update();
update.pull("sites", new Document("siteUuid", siteUuid));
return this.mongoTemplate.updateFirst(Query.query(criteria), update, User.class);
}
}
public User activate(HttpServletRequest request, HttpServletResponse response, String base64Token) {
User user = null;
UUID tokenUuid = McUuidUtils.toUuidFromBase64(base64Token);
UserToken token = (UserToken)this.findById(UserToken.class, tokenUuid);
if (token != null && token.getTokenType() == 'A') {
UUID userUuid = token.getUserUuid();
this.activate(userUuid);
user = (User)this.findById(User.class, userUuid);
this.deleteById(UserToken.class, tokenUuid);
this.emailService.sendActivatedNotification(request, response, user);
}
return user;
}
public boolean activate(UUID userUuid) {
Update update = Update.update("activated", new Date()).set("enabled", true);
return this.mongoTemplate.updateFirst(this.queryById(userUuid), update, User.class).getModifiedCount() > 0L;
}
public boolean enable(UUID userUuid, boolean enable) {
Update update = Update.update("enabled", enable);
return this.mongoTemplate.updateFirst(this.queryById(userUuid), update, User.class).getModifiedCount() > 0L;
}
public boolean switchSite(UUID userUuid, UUID siteUuid) {
Update update = new Update();
if (siteUuid == null) {
update.unset("siteUuid").unset("settings.lastSite");
} else {
update.set("siteUuid", siteUuid).set("settings.lastSite", siteUuid);
}
UpdateResult result = this.mongoTemplate.updateFirst(this.queryById(userUuid), update, User.class);
return result.getModifiedCount() > 0L;
}
public long changeGroupByUuid(UUID siteUuid, UUID groupUuid, Collection users) {
Criteria criteria = Criteria.where("sites.siteUuid").is(siteUuid).and("_id").in(users);
Query query = Query.query(criteria);
Update update = new Update();
if (groupUuid == null) {
update.unset("sites.$.groupUuid");
} else {
update.set("sites.$.groupUuid", groupUuid);
}
return this.mongoTemplate.updateMulti(query, update, User.class).getModifiedCount();
}
public long changeGroupByEmail(UUID siteUuid, UUID groupUuid, Collection emails) {
Criteria criteria = Criteria.where("sites.siteUuid").is(siteUuid).and("email").in(emails);
Query query = Query.query(criteria);
Update update = new Update();
if (groupUuid == null) {
update.unset("sites.$.groupUuid");
} else {
update.set("sites.$.groupUuid", groupUuid);
}
return this.mongoTemplate.updateMulti(query, update, User.class).getModifiedCount();
}
public boolean changeLocale(User user, String locale) {
if (user.isSameLocale(locale)) {
return true;
} else {
Update update = Update.update("settings.language", locale).set("updated", new Date());
UpdateResult result = this.mongoTemplate.updateFirst(this.queryById(user.getUuid()), update, User.class);
if (result.getModifiedCount() > 0L) {
user.setLocale(locale);
this.updateAuthorizedUser(user);
}
return result.getModifiedCount() > 0L;
}
}
public UpdateResult setSetting(User user, String key, String value) {
Update update = Update.update("settings." + key, value);
UpdateResult result = this.mongoTemplate.updateFirst(this.queryById(user.getUuid()), update, User.class);
return result;
}
public boolean setLastPage(User user, String lastPage) {
Criteria criteria = Criteria.where("_id").is(user.getUuid());
Update update = Update.update("updated", new Date());
if (user.getSiteUuid() != null && !Strings.isNullOrEmpty(lastPage)) {
criteria.and("sites.siteUuid").is(user.getSiteUuid());
if (!Strings.isNullOrEmpty(lastPage)) {
update.set("sites.$.settings.lastPage", lastPage);
} else {
update.unset("sites.$.settings.lastPage");
}
} else if (!Strings.isNullOrEmpty(lastPage)) {
update.set("settings.lastPage", lastPage);
} else {
update.unset("settings.lastPage");
}
UpdateResult result = this.mongoTemplate.updateFirst(Query.query(criteria), update, User.class);
if (result.getModifiedCount() > 0L) {
user.setLastPage(lastPage);
this.updateAuthorizedUser(user);
}
return result.getModifiedCount() > 0L;
}
public boolean setSiteSetting(User user, String key, Object value) {
Criteria criteria = Criteria.where("_id").is(user.getUuid()).and("sites.siteUuid").is(user.getSiteUuid());
Update update = Update.update("sites.$.settings." + key, value).set("updated", new Date());
UpdateResult result = this.mongoTemplate.updateFirst(Query.query(criteria), update, User.class);
return result.getModifiedCount() > 0L;
}
public boolean setPageSetting(User user, String url, DbObject settings) {
Update update = Update.update("settings.page." + url, settings);
UpdateResult result = this.mongoTemplate.updateFirst(this.queryById(user.getUuid()), update, User.class);
return result.getModifiedCount() > 0L;
}
public boolean setPageSetting(User user, String url, String key, String value) {
Update update = Update.update("settings.page." + url + "." + key, value);
UpdateResult result = this.mongoTemplate.updateFirst(this.queryById(user.getUuid()), update, User.class);
return result.getModifiedCount() > 0L;
}
public boolean setSitePageSetting(User user, UUID siteUuid, String url, Document settings) {
Criteria criteria = Criteria.where("_id").is(user.getUuid()).and("sites.siteUuid").is(siteUuid);
Update update = Update.update("sites.$.settings.page." + url, settings);
UpdateResult result = this.mongoTemplate.updateFirst(Query.query(criteria), update, User.class);
SiteInfo siteInfo = user.getSiteInfo(siteUuid);
if (siteInfo != null) {
siteInfo.getPageSetting(url).clear();
siteInfo.getPageSetting(url).putAll(settings);
}
return result.getModifiedCount() > 0L;
}
public User findUserByUserUuid(UUID userUuid) {
return userUuid == null ? null : (User)this.findById(User.class, userUuid);
}
public User findUserProfileByUserUuid(UUID userUuid) {
Query query = this.queryById(userUuid);
query.fields().include("email").include("profile");
return (User)this.mongoTemplate.findOne(query, User.class);
}
public boolean existsByEmail(String email) {
Query query = Query.query(Criteria.where("email").regex(email, "i"));
return this.mongoTemplate.exists(query, User.class);
}
public User findUserByEmail(String email, String... fields) {
return this.findUserByEmail((UUID)null, email, fields);
}
public User findUserByEmail(UUID siteUuid, String email, String... fields) {
Criteria criteria = Criteria.where("email").is(email);
if (siteUuid != null) {
criteria.and("sites.siteUuid").is(siteUuid);
}
Query query = Query.query(criteria).collation(LocaleConst.COLLATION_DEFAULT);
boolean sitesIncluded = true;
if (fields != null && fields.length > 0) {
sitesIncluded = false;
Field field = query.fields();
for(String fieldItem : fields) {
if (fieldItem == "sites") {
sitesIncluded = true;
}
field.include(fieldItem);
}
if (!sitesIncluded) {
field.include("sites");
}
}
User user = (User)this.mongoTemplate.findOne(query, User.class);
if (user != null) {
List<SiteInfo> sites = user.getSites();
if (!sites.isEmpty()) {
int count = sites.size();
Iterator<SiteInfo> siteIt = sites.iterator();
while(siteIt.hasNext()) {
SiteInfo siteInfo = (SiteInfo)siteIt.next();
if (!this.siteService.exists(siteInfo.getSiteUuid())) {
siteIt.remove();
}
}
if (sites.size() != count) {
this.save(user);
}
}
if (user.getSiteInfo(user.getSiteUuid()) == null) {
user.setSiteUuid((UUID)null);
}
}
return user;
}
public User findLastestVisitor(UUID siteUuid) {
JsonObject jFilter = new JsonObject();
jFilter.addProperty("sites.siteUuid", siteUuid.toString());
String sortBy = "updated";
List<User> users = this.find(User.class, jFilter, sortBy, Direction.DESC);
return users.isEmpty() ? null : (User)users.get(0);
}
public boolean matchPassword(User user, String password) {
if (!Strings.isNullOrEmpty(user.getPassword()) && !Strings.isNullOrEmpty(password)) {
return this.passwordEncoder.matches(password, user.getPassword()) || user.getPassword().equals(password);
} else {
return false;
}
}
public void encodePassword(User user) {
user.encodePassword(this.passwordEncoder);
}
public User findUser(UUID userUuid, String email) {
User user = null;
if (userUuid != null) {
user = (User)this.findById(User.class, userUuid);
}
if (user == null && !Strings.isNullOrEmpty(email)) {
user = this.findUserByEmail(email);
}
return user;
}
public Page findUsers(UUID siteUuid, String filter, Integer page, Integer size, String sortBy, String direction) {
if (McStringUtils.isNullOrEmpty(sortBy)) {
sortBy = "profile.name";
direction = "asc";
}
JsonObject jFilter = McStringUtils.isNullOrEmpty(filter) ? new JsonObject() : McJsonUtils.toJsonElement(filter).getAsJsonObject();
if (siteUuid != null) {
jFilter.addProperty("sites.siteUuid", siteUuid.toString());
}
Criteria criteria = McMongoUtils.toCriteria(jFilter);
Query query = new Query(criteria);
long total = this.mongoTemplate.count(query, User.class);
Sort sort = Sort.by(McMongoUtils.toDirection(direction), new String[]{sortBy});
query.with(sort);
query.collation(LocaleConst.COLLATION_DEFAULT);
Pageable pageable = PageRequest.of(page, size);
List<User> result = this.mongoTemplate.find(query.with(pageable), User.class);
Page<User> pageResult = new PageImpl(result, pageable, total);
for(User user : pageResult.getContent()) {
SiteInfo siteInfo = user.getSiteInfo(siteUuid);
user.setSiteInfo(siteInfo);
user.setSites((List)null);
}
return pageResult;
}
public UpdateResult updateSystemRoles(String command, String role, List uuids) {
Criteria criteria = Criteria.where("_id").in(uuids);
Update update = new Update();
if (command.equals("remove")) {
criteria.and("systemRoles").is(role);
update.pull("systemRoles", role);
} else {
criteria.and("systemRoles").nin(new Object[]{role});
update.push("systemRoles", role);
}
return this.mongoTemplate.updateMulti(Query.query(criteria), update, User.class);
}
public UpdateResult updateRoles(User user, UUID siteUuid, Set roles, Boolean apiOnly) {
Criteria criteria = Criteria.where("_id").is(user.getUuid()).and("sites.siteUuid").is(siteUuid);
Update update = Update.update("sites.$.roles", roles).unset("sites.$.settings.lastPage");
if (apiOnly != null) {
update.set("sites.$.apiOnly", apiOnly);
}
return this.mongoTemplate.updateFirst(Query.query(criteria), update, User.class);
}
public List findUsersBySite(UUID siteUuid) {
Query query = Query.query(Criteria.where("sites.siteUuid").is(siteUuid));
return this.mongoTemplate.find(query, User.class);
}
public List findSupervisors(UUID siteUuid) {
Query query = new Query();
query.addCriteria(Criteria.where("sites").elemMatch(Criteria.where("siteUuid").is(siteUuid).and("roles").is("SUPERVISOR")));
return this.mongoTemplate.find(query, User.class);
}
public long countSupervisor(UUID siteUuid) {
Query query = new Query();
query.addCriteria(Criteria.where("sites").elemMatch(Criteria.where("siteUuid").is(siteUuid).and("roles").is("SUPERVISOR")));
return this.mongoTemplate.count(query, User.class);
}
public Page findSupervisors(UUID siteUuid, String filter, Integer page, Integer size, String sortBy, String direction) {
if (McStringUtils.isNullOrEmpty(sortBy)) {
sortBy = "profile.name";
direction = "asc";
}
Query query = new Query(McMongoUtils.toCriteria(filter));
query.addCriteria(Criteria.where("sites").elemMatch(Criteria.where("siteUuid").is(siteUuid).and("roles").is("SUPERVISOR")));
query.collation(LocaleConst.COLLATION_DEFAULT);
long total = this.mongoTemplate.count(query, User.class);
Sort sort = Sort.by(McMongoUtils.toDirection(direction), new String[]{sortBy});
query.with(sort);
Pageable pageable = PageRequest.of(page, size);
List<User> result = this.mongoTemplate.find(query.with(pageable), User.class);
Page<User> pageResult = new PageImpl(result, pageable, total);
for(User user : pageResult.getContent()) {
SiteInfo siteInfo = user.getSiteInfo(siteUuid);
user.setSiteInfo(siteInfo);
user.setSites((List)null);
}
return pageResult;
}
public List findSystemAdmin() {
Criteria criteria = Criteria.where("systemRoles").is("SYSTEM_ADMIN").and("isEnabled").is(true);
Query query = new Query(criteria);
return this.mongoTemplate.find(query, User.class);
}
public long getUserCount(UUID siteUuid) {
Query query = Query.query(Criteria.where("sites.siteUuid").is(siteUuid));
return this.mongoTemplate.count(query, User.class);
}
public List findUser(UUID siteUuid) {
Query query = Query.query(Criteria.where("sites.siteUuid").is(siteUuid));
return this.mongoTemplate.find(query, User.class);
}
public void updateLoginAttempt(User user, boolean succeed) {
Criteria criteria = Criteria.where("_id").is(user.getUuid());
Update update;
if (succeed) {
user.resetLoginAttempt();
update = (new Update()).unset("settings.loginAttempt");
} else {
user.loginFailed();
update = Update.update("settings.loginAttempt", user.getLoginAttempt());
}
this.mongoTemplate.updateFirst(Query.query(criteria), update, user.getClass());
}
public void deleteUser(UUID userUuid) {
if (userUuid != null) {
this.deleteTokenByUser(userUuid);
this.logService.clearAllLogsFor(userUuid);
this.deviceService.removeOwner(userUuid);
this.deleteById(User.class, userUuid);
String userFilePath = Joiner.on('/').join(this.settingsService.getFilesRootPath(), "user", new Object[]{userUuid});
(new McFile(userFilePath)).delete();
}
}
public void delete(User user) {
if (user != null && user.getUuid() != null) {
this.deleteUser(user.getUuid());
}
}
public void deleteUserByEmail(String email) {
User user = this.findUserByEmail(email);
if (user != null) {
this.deleteUser(user.getUuid());
}
}
public User update(User user) {
User existingUser = (User)this.findById(User.class, user.getUuid());
return existingUser == null ? null : (User)this.saveDocument(user);
}
public UpdateResult updateProfile(User user) {
Update update = Update.update("profile", user.getProfile());
return this.mongoTemplate.updateFirst(this.queryById(user.getUuid()), update, User.class);
}
public UserToken save(UserToken token) {
if (token.getTokenType() != 'D') {
this.deleteTokenByType(token);
} else {
this.deleteDeviceAccessToken(token);
}
return (UserToken)this.saveDocument(token);
}
public UserToken renew(UserToken token) {
this.delete(token);
token.renew();
return (UserToken)this.saveDocument(token);
}
public UserToken findToken(User user, Character tokenType) {
if (user != null && user.getUuid() != null && tokenType != null) {
Query query = Query.query(Criteria.where("userUuid").is(user.getUuid()).and("tokenType").is(tokenType));
return (UserToken)this.mongoTemplate.findOne(query, UserToken.class);
} else {
return null;
}
}
public UserToken findToken(UUID tokenUuid) {
UserToken token = tokenUuid == null ? null : (UserToken)this.findById(UserToken.class, tokenUuid);
if (token != null && token.isExpired()) {
this.delete(token);
token = null;
}
return token;
}
public UserToken findToken(String tokenBase64) {
UUID tokenUuid = McUuidUtils.toUuidFromBase64(tokenBase64);
return tokenUuid == null ? null : (UserToken)this.findById(UserToken.class, tokenUuid);
}
public void delete(UserToken token) {
if (token != null) {
this.deleteById(UserToken.class, token.getTokenUuid());
}
}
public void deleteTokenByType(UserToken token) {
this.deleteToken(token.getUserUuid(), token.getTokenType());
}
public void deleteTokenByUser(UUID userUuid) {
Query query = Query.query(Criteria.where("userUuid").is(userUuid));
this.mongoTemplate.remove(query, UserToken.class);
}
public void deleteLoginToken(User user) {
this.deleteToken(user, 'L');
}
public void deleteToken(User user, char tokenType) {
this.deleteToken(user.getUuid(), tokenType);
}
public void deleteToken(UUID userUuid, char tokenType) {
Query query = Query.query(Criteria.where("userUuid").is(userUuid).and("tokenType").is(tokenType));
this.mongoTemplate.remove(query, UserToken.class);
}
public void deleteDeviceAccessToken(UserToken token) {
Query query = Query.query(Criteria.where("reference.deviceUuid").is(token.getDeviceUuid()).and("tokenType").is(token.getTokenType()));
this.mongoTemplate.remove(query, UserToken.class);
}
public Authentication authorizeLogin(User user) {
UserToken token = new UserToken(user, 'L', 604800000L);
token.encryptToken();
Authentication authentication = new UsernamePasswordAuthenticationToken(new UserPrincipal(user), token, user.getAuthorities());
SecurityContextHolder.getContext().setAuthentication(authentication);
this.save(token);
if (user.getSiteUuid() != null) {
Site site = this.siteService.findByUuid(user.getSiteUuid());
if (site != null) {
user.setSite(site);
}
}
return authentication;
}
public Authentication updateAuthorizedUser(User user) {
Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
UserToken token = this.findToken(user, 'L');
if (token == null) {
return this.authorizeLogin(user);
} else {
authentication = new UsernamePasswordAuthenticationToken(new UserPrincipal(user), token, user.getAuthorities());
SecurityContextHolder.getContext().setAuthentication(authentication);
return authentication;
}
}
public Authentication authorizeLogin(UUID tokenUuid) {
UserToken token = this.findToken(tokenUuid);
if (token == null) {
return null;
} else if (token.isExpired()) {
this.delete(token);
return null;
} else {
this.delete(token);
User user = this.findUserByUserUuid(token.getUserUuid());
return this.authorizeLogin(user);
}
}
public User authorizedUser(Authentication authentication, String accessToken) {
User user = UserPrincipal.getUser(authentication);
if (user == null && !Strings.isNullOrEmpty(accessToken) && accessToken.startsWith("Bearer")) {
try {
UUID tokenUuid = McUuidUtils.toUuidFromBase64(accessToken.substring(7));
UserToken token = this.findToken(tokenUuid);
if (token != null) {
if (token.isExpired()) {
this.delete(token);
} else {
user = this.findUserByUserUuid(token.getUserUuid());
}
}
} catch (Exception var6) {
}
}
return user;
}
public UserGroup save(UserGroup group) {
if (group.getUuid() == null) {
group.init();
}
return (UserGroup)this.saveDocument(group);
}
public UserGroup findUserGroup(UUID groupUuid) {
return groupUuid == null ? null : (UserGroup)this.findById(UserGroup.class, groupUuid);
}
public UserGroup findUserGroup(UUID siteUuid, String path) {
if (McStringUtils.isNullOrEmpty(path)) {
return null;
} else {
String[] elements = path.split(Pattern.quote("/"));
UserGroup parentGroup = null;
for(String name : elements) {
UserGroup group = this.findUserGroup(siteUuid, parentGroup, name);
if (group == null) {
parentGroup = this.save(new UserGroup(siteUuid, parentGroup, name));
} else {
parentGroup = group;
}
}
return parentGroup;
}
}
public List findUserGroupByName(UUID siteUuid, String name) {
if (siteUuid == null) {
return null;
} else {
String sortBy = "profile.hardware.serial_number";
JsonObject jFilter = this.getProfileFilter("name", name);
jFilter.addProperty("siteUuid", siteUuid.toString());
List<UserGroup> groups = this.find(UserGroup.class, jFilter, "profile.hardware.serial_number", Direction.ASC);
return groups;
}
}
private UserGroup findUserGroup(UUID siteUuid, UserGroup parent, String childName) {
if (siteUuid == null) {
return null;
} else {
Criteria criteria = Criteria.where("siteUuid").is(siteUuid).and("profile.name").is(childName);
if (parent == null) {
criteria.and("parentUuid").isNull();
} else {
criteria.and("parentUuid").is(parent.getUuid());
}
return (UserGroup)this.mongoTemplate.findOne(Query.query(criteria), UserGroup.class);
}
}
public List findAllUserGroups(UUID siteUuid) {
Sort sort = Sort.by(new String[]{"parentUuid"}).and(Sort.by(new String[]{"order"})).and(Sort.by(new String[]{"profile.name"}));
Query queryBySite = Query.query(Criteria.where("siteUuid").is(siteUuid));
queryBySite.with(sort);
List<UserGroup> groups = this.mongoTemplate.find(queryBySite, UserGroup.class);
for(UserGroup group : groups) {
UUID groupUuid = group.getUuid();
if (groupUuid != null) {
Query queryByGroup = Query.query(Criteria.where("sites.groupUuid").is(groupUuid));
Long numbers = this.mongoTemplate.count(queryByGroup, User.class);
group.setUserNumbers(numbers);
}
}
return groups;
}
public Page findUserGroup(JsonObject filter, Integer page, Integer size, String sortBy, Sort.Direction direction) {
if (McStringUtils.isNullOrEmpty(sortBy)) {
sortBy = "profile.name";
direction = Direction.ASC;
}
List<UserGroup> result = this.find(UserGroup.class, filter, sortBy, direction);
return new PageImpl(result.subList(McDbUtils.from(page, size), McDbUtils.to(page, size, result.size())), PageRequest.of(page, size), (long)result.size());
}
public void delete(UserGroup group) {
if (group != null && group.getUuid() != null) {
Query queryByParent = Query.query(Criteria.where("parentUuid").is(group.getUuid()));
for(UserGroup childGroup : this.mongoTemplate.find(queryByParent, UserGroup.class)) {
this.delete(childGroup);
}
this.deleteById(UserGroup.class, group.getUuid());
Query query = Query.query(Criteria.where("sites.groupUuid").is(group.getUuid()));
Update update = (new Update()).unset("sites.$.groupUuid");
this.mongoTemplate.updateMulti(query, update, User.class);
}
}
public DeleteResult deleteUserGroupBySiteUuid(UUID siteUuid) {
Query query = Query.query(Criteria.where("siteUuid").is(siteUuid));
return this.mongoTemplate.remove(query, UserGroup.class);
}
@Async
public void clearExpiredTokens() {
this.mongoTemplate.remove(Query.query(Criteria.where("expired").lt(new Date())), UserToken.class);
}
@Async
public void updateUserNameIfNotExists() {
Query query = Query.query(Criteria.where("profile.name").exists(false));
for(User user : this.mongoTemplate.find(query, User.class)) {
String email = user.getEmail();
if (McEmailUtils.isValid(email)) {
String name = user.getEmail().substring(0, user.getEmail().indexOf("@"));
this.mongoTemplate.updateFirst(Query.query(Criteria.where("_id").is(user.getUuid())), Update.update("profile.name", name), User.class);
} else {
this.mongoTemplate.remove(user);
}
}
}
}