aboutsummaryrefslogblamecommitdiff
path: root/src/main/java/com/juick/www/api/Users.java
blob: 124632d01ce016a755c1f0f1a08206ef19579edd (plain) (tree)
1
2
  
                                 













                                                                           
                          
 






                             
                                     
                                         







                                                         


                                              
                            
 
                                     
                                                  
                                            
                                                             
                                          
                                                 
                                                       
 
   
                 
               
                    
           
                                    
                                            
           
                                            
                                      
           
                                  
                          
           
                                          
           
                                                                
 
                                                                                                                  
                                 
                                         
                                                                                   
                                             
 


                                                        
                                                                 
         
                                                                
                             
                         
                                     
                                                            
                                                      
         
 

                                          
                          
                                                           

                                         
                                                                   

                                                                  




                                                                   
                                                   
                                                                         
                                                       
     
                           
                                                      

















                                                                                                                         
                                                                                                                 









                                                                                
                                                                     
                          
                                                               




                                                                         
                                     
                                                                         
                                                                    
     
                                  
                                                        
                                                                                   
                                                                                                                        
                                                    
                                                              
                                                                                       
         
 
                                                                                                                       
                                    
                                         
                                         
                    
                            
                                   
                
                                             
                                                          
                                       




                                     
                                                                 
                                                                      
                           


                                          
                                                                                                                          
                                       
                                         
                                         
                    
                            
                                   
                
                                             
                                                          
                                       




                                     
                                                                 
                                                                      
                           

                                          
 
                                    
                                                                                       
                                                     
                                                              
                                                      



                                                 
               



                                                                            





                                                                
                                                                          
     
                                          
 

                                 








                                                                     
                                                             
                                         
                                                              
                                                      
                                                                   
         
     
 
/*
 * Copyright (C) 2008-2020, Juick
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

package com.juick.www.api;

import java.io.IOException;
import java.net.URI;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import javax.inject.Inject;

import com.juick.model.AnonymousUser;
import com.juick.model.ApplicationStatus;
import com.juick.model.User;
import com.juick.service.EmailService;
import com.juick.service.MessagesService;
import com.juick.service.StorageService;
import com.juick.service.TagService;
import com.juick.service.TelegramService;
import com.juick.service.UserService;
import com.juick.service.activities.UpdateUserEvent;
import com.juick.service.component.MailVerificationEvent;
import com.juick.util.HttpBadRequestException;
import com.juick.util.HttpNotFoundException;
import com.juick.util.HttpUtils;
import com.juick.util.WebUtils;
import com.juick.www.WebApp;

import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.RandomStringUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

/**
 * @author ugnich
 */
@RestController
public class Users {
    @Inject
    private UserService userService;
    @Inject
    private MessagesService messagesService;
    @Inject
    private TelegramService telegramService;
    @Inject
    private EmailService emailService;
    @Inject
    private TagService tagService;
    @Inject
    private WebApp webApp;
    @Inject
    private StorageService storageService;
    @Inject
    private ApplicationEventPublisher applicationEventPublisher;

    @RequestMapping(value = "/api/users", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
    public List<User> doGetUsers(
            @ModelAttribute User visitor,
            @RequestParam(value = "uname", required = false) List<String> unames) {
        List<User> users = new ArrayList<>();

        if (unames != null) {
            unames.removeIf(WebUtils::isNotUserName);

            if (!unames.isEmpty() && unames.size() < 20)
                users.addAll(userService.getUsersByName(unames));
        }
        users.forEach(u -> u.setAvatar(webApp.getAvatarUrl(u)));
        if (!users.isEmpty())
            return users;
        if (!visitor.isAnonymous()) {
            visitor.setAvatar(webApp.getAvatarUrl(visitor));
            return Collections.singletonList(visitor);
        }

        throw new HttpNotFoundException();
    }

    @GetMapping("/api/me")
    public SecureUser getMe(@ModelAttribute User visitor) {
        SecureUser me = new SecureUser();
        me.setUid(visitor.getUid());
        me.setName(visitor.getName());
        me.setAuthHash(userService.getHashByUID(visitor.getUid()));
        List<Integer> unread = messagesService.getUnread(visitor);
        me.setUnread(unread);
        me.setUnreadCount(unread.size());
        var friends = userService.getUserFriends(visitor.getUid());
        friends.forEach(r -> r.setAvatar(webApp.getAvatarUrl(r)));
        me.setRead(friends);
        var readers = userService.getUserReaders(visitor.getUid());
        readers.forEach(r -> r.setAvatar(webApp.getAvatarUrl(r)));
        me.setReaders(readers);
        me.setAvatar(webApp.getAvatarUrl(visitor));
        me.getTagStats().addAll(tagService.getUserTagStats(me.getUid()));
        return (SecureUser)userService.getUserInfo(me);
    }
    @PostMapping("/api/me")
    public void updateMe(@ModelAttribute User visitor,
                                         @RequestParam(required = false) String password,
                                         @RequestParam(value = "jid-del", required = false) String jidForDeletion,
                                         @RequestParam(value = "email-add", required = false) String newEmail,
                                         @RequestParam(value = "email-del", required = false) String emailForDeletion,
                                         @RequestParam(value = "account-del", required = false) String accountToDelete) {
        if (StringUtils.isNotEmpty(password)) {
            if (!userService.updatePassword(visitor, password)) {
                throw new HttpBadRequestException();
            }
        }
        if (StringUtils.isNotEmpty(jidForDeletion)) {
            if (!userService.deleteJID(visitor.getUid(), jidForDeletion)) {
                throw new HttpBadRequestException();
            }
        }
        if (StringUtils.isNotEmpty(newEmail)) {
            if (!emailService.verifyAddressByCode(visitor.getUid(), newEmail)) {
                String authCode = RandomStringUtils.randomAlphanumeric(8).toUpperCase();
                if (emailService.addVerificationCode(visitor.getUid(), newEmail, authCode)) {
                    applicationEventPublisher.publishEvent(new MailVerificationEvent(this, newEmail , authCode));
                }
            }
        }
        if (StringUtils.isNotEmpty(emailForDeletion)) {
            if (!emailService.deleteEmail(visitor.getUid(), emailForDeletion)) {
                throw new HttpBadRequestException();
            }
        }
        if (StringUtils.isNotEmpty(accountToDelete)) {
            switch (accountToDelete) {
                case "twitter":
                    userService.deleteTwitterToken(visitor.getUid());
                    break;
                case "vk":
                    userService.deleteVKUser(visitor.getUid());
                    break;
                case "durov":
                    telegramService.deleteTelegramUser(visitor.getUid());
                    break;
            }
        }
    }
    @PostMapping("/api/me/subscribe")
    public void subscribeMe(@ModelAttribute User visitor, String email) {
        // TODO: check status
        emailService.setNotificationsEmail(visitor.getUid(), email);
    }
    @PostMapping("/api/me/upload")
    public void updateInfo(@ModelAttribute User visitor,
                           @RequestParam MultipartFile avatar) throws IOException {
        String avatarTmpPath = HttpUtils.receiveMultiPartFile(avatar, storageService.getTemporaryDirectory()).getHost();
        if (StringUtils.isNotEmpty(avatarTmpPath)) {
            storageService.saveAvatar(avatarTmpPath, visitor);
            applicationEventPublisher.publishEvent(new UpdateUserEvent(this, visitor));
        }
    }

    @RequestMapping(value = "/api/users/read", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
    public List<User> doGetUserRead(
            @ModelAttribute User visitor,
            @RequestParam String uname) {
        int uid = 0;
        if (uname == null) {
            uid = visitor.getUid();
        } else {
            if (WebUtils.isUserName(uname)) {
                User u = userService.getUserByName(uname);
                if (!u.isAnonymous()) {
                    uid = u.getUid();
                }
            }
        }

        if (uid > 0) {
            List<User> friends = userService.getUserFriends(uid);
            friends.forEach(f -> f.setAvatar(webApp.getAvatarUrl(f)));
            return friends;
        }
        throw new HttpNotFoundException();
    }

    @RequestMapping(value = "/api/users/readers", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
    public List<User> doGetUserReaders(
            @ModelAttribute User visitor,
            @RequestParam String uname) {
        int uid = 0;
        if (uname == null) {
            uid = visitor.getUid();
        } else {
            if (WebUtils.isUserName(uname)) {
                User u = userService.getUserByName(uname);
                if (!u.isAnonymous()) {
                    uid = u.getUid();
                }
            }
        }

        if (uid > 0) {
            List<User> readers = userService.getUserReaders(uid);
            readers.forEach(r -> r.setAvatar(webApp.getAvatarUrl(r)));
            return readers;
        }
        throw new HttpNotFoundException();
    }

    @GetMapping("/api/info/{uname}")
    public User getUserInfo(@ModelAttribute User visitor, @PathVariable String uname) {
        User user = userService.getUserByName(uname);
        if (!user.isBanned()) {
            user.setRead(doGetUserRead(visitor, uname));
            user.setReaders(doGetUserReaders(visitor, uname));
            user.setAvatar(webApp.getAvatarUrl(user));
            return userService.getUserInfo(user);
        }
        throw new HttpNotFoundException();
    }

    @Deprecated
    @GetMapping(value = "/api/avatar", produces = MediaType.IMAGE_PNG_VALUE)
    public byte[] getAvatarUrl(
            @RequestParam(required = false) String uname,
            @RequestParam(required = false) String jid)
            throws IOException {
        User user = AnonymousUser.INSTANCE;
        if (StringUtils.isNotEmpty(uname)) {
            user = userService.getUserByName(uname);
        }
        if (user.isAnonymous() && StringUtils.isNotEmpty(jid)) {
            user = userService.getUserByJID(jid);
        }
        return IOUtils.toByteArray(URI.create(webApp.getAvatarUrl(user)));
    }
    public class SecureUser extends User {

        public String getHash() {
            return getAuthHash();
        }
        public List<String> getJIDs() {
            return userService.getAllJIDs(this);
        }
        public List<String> getEmails() {
            return userService.getEmails(this);
        }
        public String getActiveEmail() {
            return emailService.getNotificationsEmail(this.getUid());
        }
        public String getTwitterName() {
            return userService.getTwitterName(this.getUid());
        }
        public String getTelegramName() {
            return userService.getTelegramName(this.getUid());
        }
        public ApplicationStatus getFacebookStatus() {
            return userService.getFbCrossPostStatus(this.getUid());
        }
    }
}