CustomSimpleIPv6Handler.java

package ru.test.bgbilling.modules.inet.ip.handler;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import ru.bitel.bgbilling.common.BGException;
import ru.bitel.bgbilling.common.BGMessageException;
import ru.bitel.bgbilling.kernel.network.radius.RadiusListenerWorker;
import ru.bitel.bgbilling.kernel.network.radius.RadiusPacket;
import ru.bitel.bgbilling.modules.inet.common.bean.InetServ;
import ru.bitel.bgbilling.modules.inet.common.bean.InetServType;
import ru.bitel.bgbilling.modules.inet.common.bean.InetServTypeIPMode;
import ru.bitel.bgbilling.modules.inet.server.bean.InetServDao;
import ru.bitel.bgbilling.modules.inet.server.ip.AbstractInetServIpHandler;
import ru.bitel.bgbilling.modules.inet.server.ip.InetServIpData;
import ru.bitel.bgbilling.modules.inet.server.ip.InetServIpHandler;
import ru.bitel.common.TimeUtils;
import ru.bitel.common.inet.IpAddress;
import ru.bitel.common.inet.IpNet;
import ru.bitel.common.logging.BGNestedContext;
import ru.bitel.oss.systems.inventory.resource.common.bean.IpResource;
import ru.bitel.oss.systems.inventory.resource.common.bean.IpResourceSubscription;
import ru.bitel.oss.systems.inventory.resource.common.service.ResourceService;

import java.util.List;

public class CustomSimpleIPv6Handler
        extends AbstractInetServIpHandler
        implements InetServIpHandler {
    private final static Logger logger = LogManager.getLogger();

    @Override
    public void checkAddress(InetServ inetServ, InetServType servType)
            throws BGMessageException {
        // проверка на ввод Framed-IPv6-Address
        // if ( inetServ.getFramedIPv6Address() == null )
        // {
        //      throw new BGMessageException( "Не указан Framed-IPv6-Address" );
        // }
        InetServTypeIPMode iPv6Mode = getIPv6Mode(servType);
        if (iPv6Mode.isSelectStatic() && !iPv6Mode.isSelectNo()) {
            // проверка на ввод Framed-IPv6-Prefix
            if (inetServ.getFramedIPv6Prefix() == null) {
                throw new BGMessageException("Не указан Framed-IPv6-Prefix");
            }

            // проверка на ввод Delegated-IPv6-Prefix
            if (inetServ.getDelegatedIPv6Prefix() == null) {
                throw new BGMessageException("Не указан Delegated-IPv6-Prefix");
            }
        }
    }

    @Override
    public void setAddress(InetServ newInetServ, InetServType servType, InetServ oldInetServ, int subscriberId, String subscriberTitle)
            throws BGException {
        // FramedIPv6Prefix
        subscriptionFramedIPv6Prefix(oldInetServ, newInetServ, subscriberId, subscriberTitle);
        // DelegatedIPv6Prefix
        subscriptionDelegatedIPv6Prefix(oldInetServ, newInetServ, subscriberId, subscriberTitle);
    }

    protected void subscriptionFramedIPv6Prefix(InetServ oldInetServ, InetServ newInetServ, int subscriberId, String subscriberTitle)
            throws BGException {
        byte[] oldPrefix = oldInetServ == null ? null : oldInetServ.getFramedIPv6Prefix();
        short oldPrefixLength = oldInetServ == null ? 0 : oldInetServ.getFramedIPv6PrefixLength();

        byte[] newPrefix = newInetServ.getFramedIPv6Prefix();
        short newPrefixLength = newInetServ.getFramedIPv6PrefixLength();

        subscriptionIPv6Prefix("Framed", oldInetServ, newInetServ, oldPrefix, oldPrefixLength, newPrefix, newPrefixLength, subscriberId, subscriberTitle);
    }

    protected void subscriptionDelegatedIPv6Prefix(InetServ oldInetServ, InetServ newInetServ, int subscriberId, String subscriberTitle)
            throws BGException {
        byte[] oldPrefix = oldInetServ == null ? null : oldInetServ.getDelegatedIPv6Prefix();
        short oldPrefixLength = oldInetServ == null ? 0 : oldInetServ.getDelegatedIPv6PrefixLength();

        byte[] newPrefix = newInetServ.getDelegatedIPv6Prefix();
        short newPrefixLength = newInetServ.getDelegatedIPv6PrefixLength();

        subscriptionIPv6Prefix("Delegated", oldInetServ, newInetServ, oldPrefix, oldPrefixLength, newPrefix, newPrefixLength, subscriberId, subscriberTitle);
    }

    protected void subscriptionIPv6Prefix(String prefixType, InetServ oldInetServ, InetServ newInetServ,
                                          byte[] oldPrefix, short oldPrefixLength, byte[] newPrefix, short newPrefixLength,
                                          int subscriberId, String subscriberTitle)
            throws BGException {
        boolean needSubscription = oldInetServ == null ||
                (!IpAddress.equals(oldPrefix, newPrefix) ||
                        !((oldInetServ.getDateFrom() == null && newInetServ.getDateFrom() == null) || TimeUtils.dateEqual(oldInetServ.getDateFrom(), newInetServ.getDateFrom())) ||
                        !((oldInetServ.getDateTo() == null && newInetServ.getDateTo() == null) || TimeUtils.dateEqual(oldInetServ.getDateTo(), newInetServ.getDateTo())));

        ResourceService resourceService = context.getService(ResourceService.class, moduleId);
        List<Integer> ipResourceCategoryIds = inetServService.ipResourceCategoryIds(newInetServ.getDeviceId(), newInetServ.getInterfaceId(), newInetServ.getTypeId());

        // проверяем есть ли этот ресурс в этой категории (на случай если
        // категорию на устройстве поменяли, нужно менять подписку)
        if (oldInetServ != null) {
            boolean need = true;
            int ipResourceId = "Framed".equals(prefixType) ? oldInetServ.getFramedIPv6PrefixResourceId() : oldInetServ.getDelegatedIPv6PrefixResourceId();
            for (IpResource ipResource : resourceService.ipResourceList(ipResourceCategoryIds)) {
                if (ipResourceId == ipResource.getId()) {
                    need = false;
                    break;
                }
            }
            needSubscription |= need;
        }

        if (needSubscription) {
            InetServDao inetServDao = new InetServDao(this.context.getConnectionSet().getConnection(), this.moduleId);
            // если поменялся адрес на сервисе, отменяем подписку на старый адрес
            if (oldInetServ != null && oldPrefix != null) {
                if ("Framed".equals(prefixType)) {
                    resourceService.ipResourceUnsubscribe(subscriberId, oldInetServ.getFramedIPv6PrefixResourceSubscriptionId(), oldPrefix, (new IpNet(oldPrefix, oldPrefixLength)).getBroadcast());
                    newInetServ.setFramedIPv6PrefixResourceId(0);
                    newInetServ.setFramedIPv6PrefixResourceSubscriptionId(0);
                } else if ("Delegated".equals(prefixType)) {
                    resourceService.ipResourceUnsubscribe(subscriberId, oldInetServ.getDelegatedIPv6PrefixResourceSubscriptionId(), oldPrefix, (new IpNet(oldPrefix, oldPrefixLength)).getBroadcast());
                    newInetServ.setDelegatedIPv6PrefixResourceId(0);
                    newInetServ.setDelegatedIPv6PrefixResourceSubscriptionId(0);
                }
                inetServDao.update(newInetServ);
            }

            // подписка на новый адрес
            if (newPrefix != null) {
                IpResourceSubscription subscription = resourceService.ipResourceSubscribe(subscriberId, subscriberTitle, ipResourceCategoryIds, 0, newPrefix, (new IpNet(newPrefix, newPrefixLength)).getBroadcast(), newInetServ.getDateFrom(), newInetServ.getDateTo());
                if ("Framed".equals(prefixType)) {
                    newInetServ.setFramedIPv6PrefixResourceId(subscription.getIpResourseId());
                    newInetServ.setFramedIPv6PrefixResourceSubscriptionId(subscription.getId());
                } else if ("Delegated".equals(prefixType)) {
                    newInetServ.setDelegatedIPv6PrefixResourceId(subscription.getIpResourseId());
                    newInetServ.setDelegatedIPv6PrefixResourceSubscriptionId(subscription.getId());
                }

                inetServDao.update(newInetServ);
            }
            inetServDao.close();
        }
    }

    @Override
    public boolean setRadiusIp(InetServIpData inetServIpData, RadiusPacket request, RadiusPacket response) {
        InetServ inetServ = inetServIpData.getInetServ();
        RadiusListenerWorker<?> radiusListenerWorker = inetServIpData.getRadiusListenerWorker();

        // установка Framed-IPv6-Address
//        final byte[] framedAddress = inetServ.getFramedIPv6Address();
//        if ( framedAddress != null )
//        {
//            setFramedIPAddress( radiusListenerWorker, response, inetServ.getFramedIPv6AddressResourceId(), framedAddress );
//        }

        // установка Framed-IPv6-Prefix
        final byte[] framedPrefix = inetServ.getFramedIPv6Prefix();
        if (framedPrefix != null) {
            setFramedIPv6Prefix(radiusListenerWorker, response, inetServ.getFramedIPv6PrefixResourceId(), framedPrefix, inetServ.getFramedIPv6PrefixLength());
        }

        // установка Delegated-IPv6-Prefix
        final byte[] delegatedPrefix = inetServ.getDelegatedIPv6Prefix();
        if (delegatedPrefix != null) {
            setDelegatedIPv6Prefix(radiusListenerWorker, response, inetServ.getDelegatedIPv6PrefixResourceId(), delegatedPrefix, inetServ.getDelegatedIPv6PrefixLength());
        }

        return true;
    }
}