838 lines
31 KiB
Java
838 lines
31 KiB
Java
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<User> saveUsers(List<User> 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);
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|