intra-back/src/main/java/fr/la_banquise/backend/services/JiService.java

package fr.la_banquise.backend.services;

import fr.la_banquise.backend.data.model.Instance;
import fr.la_banquise.backend.data.model.Ji;
import fr.la_banquise.backend.data.model.Site;
import fr.la_banquise.backend.data.model.User;
import fr.la_banquise.backend.data.repository.JiRepository;
import fr.la_banquise.backend.data.repository.UserRepository;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import jakarta.transaction.Transactional;
import jakarta.ws.rs.core.SecurityContext;
import java.util.List;

@ApplicationScoped
public class JiService {

    @Inject JiRepository jiRepository;
    @Inject UserRepository userRepository;
    @Inject SiteService siteService;
    @Inject UserService userService;
    @Inject InstanceService instanceService;
    @Inject SecurityContext security;

    ///////////////////////////////////////////////////////////////////////////
    ///
    /// First, we create our JI and basic functions
    @Transactional
    public Ji createJi(String name, String description, String date,
                       Long siteId, Long ownerId) {
        Site site = siteService.getSite(siteId);
        User user = userService.getUser(ownerId);
        Ji ji = new Ji(name, description, List.of(user), date, site);
        jiRepository.persist(ji);
        siteService.registerJi(site, ji);
        createInstance(user.id, ji.id);
        return ji;
    }

    public List<Ji> getAllJiAdmin() { return jiRepository.listAll(); }

    public List<Ji> getAllJiRespo(String username) {
        User user = userRepository.findByName(username);
        return user.jiRespo;
    }

    public Ji getJi(Long id) { return jiRepository.findById(id); }

    ///////////////////////////////////////////////////////////////////////////

    /// Now that the JI is created, we want to add users to it and assign them
    /// instances, but DONT create their containers yet !

    @Transactional
    public Instance createInstance(Long userId, Long jiId) {
        Ji ji = jiRepository.findById(jiId);
        Instance instance = instanceService.createInstance(userId, ji);
        ji.instances.add(instance);
        return instance;
    }

    @Transactional
    public Instance getInstance(Long jiId, Long userId) {
        Ji ji = jiRepository.findById(jiId);
        for (Instance inst : ji.instances) {
            if (inst.owner.id == userId) {
                return inst;
            }
        }
        throw new Error("Instance or user not found");
    }

    @Transactional
    public void registerUser(Long userId, Long jiId) {
        User user = userService.getUser(userId);
        Ji ji = getJi(jiId);
        ji.participants.add(user);
        createInstance(userId, jiId);
    }

    ///////////////////////////////////////////////////////////////////////////

    /// Then, when an admin decides it, we create the containers

    /*@Transactional
    public void createContainer(Long jiId, Long userId) {
        Ji ji = jiRepository.findById(jiId);
        String username = userService.getUser(userId).name;
        for (Instance instance : ji.instances) {

            if (instance.name.equals(username + "-" + jiId)) {
                instanceService.createContainer(instance.id);
                break;
            }
        }
    }*/

    // On dit a toute les instances de creer leur container.
    // Instance gere le cas ou le container existe deja.
    @Transactional
    public void createContainers(Long jiId) {
        Ji ji = jiRepository.findById(jiId);
        for (Instance instance : ji.instances) {
            instanceService.createContainer(instance.id);
        }
    }

    public String getStatusContainer(Long jiId, Long userId) {
        Ji ji = jiRepository.findById(jiId);
        String username = userService.getUser(userId).name;
        String retour = "";
        for (Instance instance : ji.instances) {
            if (instance.name.equals(username + "-" + jiId)) {
                if (instance.containerId.equals("Not created"))
                    return "Not created";
                retour = instanceService.getStatusContainer(instance.id)
                             .toString()
                             .replaceAll(".*status=([^,]+).*", "$1");
                break;
            }
        }
        if (retour == "")
            return "Not created";
        return retour;
    }

    public String getStatusContainers(Long jiId) {
        Ji ji = jiRepository.findById(jiId);
        String retour = "";
        for (Instance instance : ji.instances) {
            if (instance.containerId.equals("Not created"))
                retour += "Not created";
            else {
                retour +=
                    instanceService.getStatusContainer(instance.id).toString();
            }
        }
        return retour;
    }
    ///////////////////////////////////////////////////////////////////////////

    /// Finally, start/stop the containers

    @Transactional
    public void startContainers(Long jiId) {
        Ji ji = jiRepository.findById(jiId);
        for (Instance instance : ji.instances) {
            instanceService.startContainer(instance.id);
        }
    }

    @Transactional
    public void stopContainers(Long jiId) {
        Ji ji = jiRepository.findById(jiId);
        for (Instance instance : ji.instances) {
            instanceService.stopContainer(instance.id);
        }
    }

    ///////////////////////////////////////////////////////////////////////////

    /// Last but not least, be able do delete every container and instance

    @Transactional
    public void deleteJi(Long jiId) {
        Ji ji = getJi(jiId);
        for (Instance instance : ji.instances) {
            instanceService.deleteInstance(instance.id);
        }
        siteService.removeJi(ji.site, ji);
        jiRepository.deleteById(jiId);
    }
}