// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.
package com.cloud.api;

import java.util.ArrayList;
import java.util.EnumSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.annotation.PostConstruct;
import javax.inject.Inject;


import com.cloud.network.rules.LoadBalancer;
import com.cloud.network.vpc.NetworkACL;
import com.cloud.network.vpc.StaticRouteVO;
import com.cloud.network.vpc.VpcGatewayVO;
import com.cloud.network.vpc.VpcManager;
import com.cloud.network.vpc.VpcOffering;
import com.cloud.network.vpc.VpcProvisioningService;
import com.cloud.network.vpc.VpcVO;
import com.cloud.network.vpc.dao.NetworkACLDao;
import com.cloud.network.vpc.dao.StaticRouteDao;
import com.cloud.network.vpc.dao.VpcDao;
import com.cloud.network.vpc.dao.VpcGatewayDao;
import com.cloud.network.vpc.dao.VpcOfferingDao;
import com.cloud.region.ha.GlobalLoadBalancingRulesService;
import org.apache.cloudstack.affinity.AffinityGroup;
import org.apache.cloudstack.affinity.AffinityGroupResponse;
import org.apache.cloudstack.affinity.dao.AffinityGroupDao;
import org.apache.cloudstack.api.ApiConstants.HostDetails;
import org.apache.cloudstack.api.ApiConstants.VMDetails;
import org.apache.cloudstack.api.response.AccountResponse;
import org.apache.cloudstack.api.response.AsyncJobResponse;
import org.apache.cloudstack.api.response.DiskOfferingResponse;
import org.apache.cloudstack.api.response.DomainRouterResponse;
import org.apache.cloudstack.api.response.EventResponse;
import org.apache.cloudstack.api.response.HostForMigrationResponse;
import org.apache.cloudstack.api.response.HostResponse;
import org.apache.cloudstack.api.response.InstanceGroupResponse;
import org.apache.cloudstack.api.response.ProjectAccountResponse;
import org.apache.cloudstack.api.response.ProjectInvitationResponse;
import org.apache.cloudstack.api.response.ProjectResponse;
import org.apache.cloudstack.api.response.ResourceTagResponse;
import org.apache.cloudstack.api.response.SecurityGroupResponse;
import org.apache.cloudstack.api.response.ServiceOfferingResponse;
import org.apache.cloudstack.api.response.StoragePoolResponse;
import org.apache.cloudstack.api.response.UserResponse;
import org.apache.cloudstack.api.response.UserVmResponse;
import org.apache.cloudstack.api.response.VolumeResponse;
import org.apache.cloudstack.api.response.ZoneResponse;
import org.apache.cloudstack.lb.dao.ApplicationLoadBalancerRuleDao;
import org.apache.cloudstack.storage.datastore.db.PrimaryDataStoreDao;
import org.apache.cloudstack.storage.datastore.db.StoragePoolVO;
import org.springframework.stereotype.Component;

import com.cloud.api.query.dao.AccountJoinDao;
import com.cloud.api.query.dao.AffinityGroupJoinDao;
import com.cloud.api.query.dao.AsyncJobJoinDao;
import com.cloud.api.query.dao.DataCenterJoinDao;
import com.cloud.api.query.dao.DiskOfferingJoinDao;
import com.cloud.api.query.dao.DomainRouterJoinDao;
import com.cloud.api.query.dao.HostJoinDao;
import com.cloud.api.query.dao.InstanceGroupJoinDao;
import com.cloud.api.query.dao.ProjectAccountJoinDao;
import com.cloud.api.query.dao.ProjectInvitationJoinDao;
import com.cloud.api.query.dao.ProjectJoinDao;
import com.cloud.api.query.dao.ResourceTagJoinDao;
import com.cloud.api.query.dao.SecurityGroupJoinDao;
import com.cloud.api.query.dao.ServiceOfferingJoinDao;
import com.cloud.api.query.dao.StoragePoolJoinDao;
import com.cloud.api.query.dao.UserAccountJoinDao;
import com.cloud.api.query.dao.UserVmJoinDao;
import com.cloud.api.query.dao.VolumeJoinDao;
import com.cloud.api.query.vo.AccountJoinVO;
import com.cloud.api.query.vo.AffinityGroupJoinVO;
import com.cloud.api.query.vo.AsyncJobJoinVO;
import com.cloud.api.query.vo.DataCenterJoinVO;
import com.cloud.api.query.vo.DiskOfferingJoinVO;
import com.cloud.api.query.vo.DomainRouterJoinVO;
import com.cloud.api.query.vo.EventJoinVO;
import com.cloud.api.query.vo.HostJoinVO;
import com.cloud.api.query.vo.InstanceGroupJoinVO;
import com.cloud.api.query.vo.ProjectAccountJoinVO;
import com.cloud.api.query.vo.ProjectInvitationJoinVO;
import com.cloud.api.query.vo.ProjectJoinVO;
import com.cloud.api.query.vo.ResourceTagJoinVO;
import com.cloud.api.query.vo.SecurityGroupJoinVO;
import com.cloud.api.query.vo.ServiceOfferingJoinVO;
import com.cloud.api.query.vo.StoragePoolJoinVO;
import com.cloud.api.query.vo.UserAccountJoinVO;
import com.cloud.api.query.vo.UserVmJoinVO;
import com.cloud.api.query.vo.VolumeJoinVO;
import com.cloud.async.AsyncJob;
import com.cloud.async.AsyncJobManager;
import com.cloud.async.AsyncJobVO;
import com.cloud.async.dao.AsyncJobDao;
import com.cloud.capacity.CapacityVO;
import com.cloud.capacity.dao.CapacityDao;
import com.cloud.capacity.dao.CapacityDaoImpl.SummedCapacity;
import com.cloud.configuration.Config;
import com.cloud.configuration.ConfigurationService;
import com.cloud.configuration.Resource.ResourceType;
import com.cloud.configuration.dao.ConfigurationDao;
import com.cloud.dc.AccountVlanMapVO;
import com.cloud.dc.ClusterDetailsDao;
import com.cloud.dc.ClusterDetailsVO;
import com.cloud.dc.ClusterVO;
import com.cloud.dc.DataCenter;
import com.cloud.dc.DataCenterVO;
import com.cloud.dc.HostPodVO;
import com.cloud.dc.Vlan;
import com.cloud.dc.VlanVO;
import com.cloud.dc.dao.AccountVlanMapDao;
import com.cloud.dc.dao.ClusterDao;
import com.cloud.dc.dao.DataCenterDao;
import com.cloud.dc.dao.HostPodDao;
import com.cloud.dc.dao.VlanDao;
import com.cloud.domain.DomainVO;
import com.cloud.domain.dao.DomainDao;
import com.cloud.event.Event;
import com.cloud.event.dao.EventJoinDao;
import com.cloud.exception.InvalidParameterValueException;
import com.cloud.ha.HighAvailabilityManager;
import com.cloud.host.Host;
import com.cloud.host.HostStats;
import com.cloud.host.HostVO;
import com.cloud.host.dao.HostDao;
import com.cloud.host.dao.HostDetailsDao;
import com.cloud.hypervisor.Hypervisor.HypervisorType;
import com.cloud.network.dao.AccountGuestVlanMapDao;
import com.cloud.network.dao.AccountGuestVlanMapVO;
import com.cloud.network.IpAddress;
import com.cloud.network.Network;
import com.cloud.network.Network.Capability;
import com.cloud.network.Network.Provider;
import com.cloud.network.Network.Service;
import com.cloud.network.NetworkManager;
import com.cloud.network.NetworkModel;
import com.cloud.network.NetworkProfile;
import com.cloud.network.Networks.TrafficType;
import com.cloud.network.PhysicalNetworkServiceProvider;
import com.cloud.network.as.AutoScalePolicy;
import com.cloud.network.as.AutoScalePolicyConditionMapVO;
import com.cloud.network.as.AutoScalePolicyVO;
import com.cloud.network.as.AutoScaleVmGroupPolicyMapVO;
import com.cloud.network.as.AutoScaleVmGroupVO;
import com.cloud.network.as.AutoScaleVmProfileVO;
import com.cloud.network.as.ConditionVO;
import com.cloud.network.as.CounterVO;
import com.cloud.network.as.dao.AutoScalePolicyConditionMapDao;
import com.cloud.network.as.dao.AutoScalePolicyDao;
import com.cloud.network.as.dao.AutoScaleVmGroupDao;
import com.cloud.network.as.dao.AutoScaleVmGroupPolicyMapDao;
import com.cloud.network.as.dao.AutoScaleVmProfileDao;
import com.cloud.network.as.dao.ConditionDao;
import com.cloud.network.as.dao.CounterDao;
import com.cloud.network.dao.FirewallRulesCidrsDao;
import com.cloud.network.dao.FirewallRulesDao;
import com.cloud.network.dao.IPAddressDao;
import com.cloud.network.dao.IPAddressVO;
import com.cloud.network.dao.LoadBalancerDao;
import com.cloud.network.dao.LoadBalancerVO;
import com.cloud.network.dao.NetworkDao;
import com.cloud.network.dao.NetworkDomainDao;
import com.cloud.network.dao.NetworkDomainVO;
import com.cloud.network.dao.NetworkRuleConfigDao;
import com.cloud.network.dao.NetworkRuleConfigVO;
import com.cloud.network.dao.NetworkVO;
import com.cloud.network.dao.PhysicalNetworkDao;
import com.cloud.network.dao.PhysicalNetworkServiceProviderDao;
import com.cloud.network.dao.PhysicalNetworkServiceProviderVO;
import com.cloud.network.dao.PhysicalNetworkTrafficTypeDao;
import com.cloud.network.dao.PhysicalNetworkTrafficTypeVO;
import com.cloud.network.dao.PhysicalNetworkVO;
import com.cloud.network.dao.Site2SiteCustomerGatewayDao;
import com.cloud.network.dao.Site2SiteCustomerGatewayVO;
import com.cloud.network.dao.Site2SiteVpnGatewayDao;
import com.cloud.network.dao.Site2SiteVpnGatewayVO;
import com.cloud.network.router.VirtualRouter;
import com.cloud.network.rules.FirewallRuleVO;
import com.cloud.network.security.SecurityGroup;
import com.cloud.network.security.SecurityGroupManager;
import com.cloud.network.security.SecurityGroupVO;
import com.cloud.network.security.dao.SecurityGroupDao;
import com.cloud.offering.DiskOffering;
import com.cloud.offering.NetworkOffering;
import com.cloud.offering.ServiceOffering;
import com.cloud.offerings.NetworkOfferingVO;
import com.cloud.offerings.dao.NetworkOfferingDao;
import com.cloud.projects.Project;
import com.cloud.projects.ProjectAccount;
import com.cloud.projects.ProjectInvitation;
import com.cloud.projects.ProjectService;
import com.cloud.resource.ResourceManager;
import com.cloud.server.Criteria;
import com.cloud.server.ManagementServer;
import com.cloud.server.ResourceTag;
import com.cloud.server.ResourceTag.TaggedResourceType;
import com.cloud.server.StatsCollector;
import com.cloud.server.TaggedResourceService;
import com.cloud.service.ServiceOfferingVO;
import com.cloud.service.dao.ServiceOfferingDao;
import com.cloud.storage.DiskOfferingVO;
import com.cloud.storage.GuestOS;
import com.cloud.storage.GuestOSCategoryVO;
import com.cloud.storage.Snapshot;
import com.cloud.storage.SnapshotVO;
import com.cloud.storage.Storage.ImageFormat;
import com.cloud.storage.StorageManager;
import com.cloud.storage.StoragePool;
import com.cloud.storage.StorageStats;
import com.cloud.storage.UploadVO;
import com.cloud.storage.VMTemplateHostVO;
import com.cloud.storage.VMTemplateS3VO;
import com.cloud.storage.VMTemplateSwiftVO;
import com.cloud.storage.VMTemplateVO;
import com.cloud.storage.Volume;
import com.cloud.storage.Volume.Type;
import com.cloud.storage.VolumeHostVO;
import com.cloud.storage.VolumeManager;
import com.cloud.storage.VolumeVO;
import com.cloud.storage.dao.DiskOfferingDao;
import com.cloud.storage.dao.GuestOSCategoryDao;
import com.cloud.storage.dao.GuestOSDao;
import com.cloud.storage.dao.SnapshotDao;
import com.cloud.storage.dao.SnapshotPolicyDao;
import com.cloud.storage.dao.UploadDao;
import com.cloud.storage.dao.VMTemplateDao;
import com.cloud.storage.dao.VMTemplateDetailsDao;
import com.cloud.storage.dao.VMTemplateHostDao;
import com.cloud.storage.dao.VMTemplateS3Dao;
import com.cloud.storage.dao.VMTemplateSwiftDao;
import com.cloud.storage.dao.VolumeDao;
import com.cloud.storage.dao.VolumeHostDao;
import com.cloud.storage.snapshot.SnapshotPolicy;
import com.cloud.template.TemplateManager;
import com.cloud.user.Account;
import com.cloud.user.AccountDetailsDao;
import com.cloud.user.AccountVO;
import com.cloud.user.ResourceLimitService;
import com.cloud.user.SSHKeyPairVO;
import com.cloud.user.User;
import com.cloud.user.UserAccount;
import com.cloud.user.UserStatisticsVO;
import com.cloud.user.UserVO;
import com.cloud.user.dao.AccountDao;
import com.cloud.user.dao.SSHKeyPairDao;
import com.cloud.user.dao.UserDao;
import com.cloud.user.dao.UserStatisticsDao;
import com.cloud.uservm.UserVm;
import com.cloud.utils.NumbersUtil;
import com.cloud.utils.Pair;
import com.cloud.vm.ConsoleProxyVO;
import com.cloud.vm.DomainRouterVO;
import com.cloud.vm.InstanceGroup;
import com.cloud.vm.InstanceGroupVO;
import com.cloud.vm.NicProfile;
import com.cloud.vm.UserVmDetailVO;
import com.cloud.vm.UserVmManager;
import com.cloud.vm.UserVmVO;
import com.cloud.vm.VMInstanceVO;
import com.cloud.vm.VirtualMachine;
import com.cloud.vm.VmStats;
import com.cloud.vm.dao.ConsoleProxyDao;
import com.cloud.vm.dao.DomainRouterDao;
import com.cloud.vm.dao.NicSecondaryIpDao;
import com.cloud.vm.dao.NicSecondaryIpVO;
import com.cloud.vm.dao.UserVmDao;
import com.cloud.vm.dao.UserVmDetailsDao;
import com.cloud.vm.dao.VMInstanceDao;
import com.cloud.vm.snapshot.VMSnapshot;
import com.cloud.vm.snapshot.dao.VMSnapshotDao;

@Component
public class ApiDBUtils {
    private static ManagementServer _ms;
    static AsyncJobManager _asyncMgr;
    static SecurityGroupManager _securityGroupMgr;
    static StorageManager _storageMgr;
    static VolumeManager _volumeMgr;
    static UserVmManager _userVmMgr;
    static NetworkModel _networkModel;
    static NetworkManager _networkMgr;
    static TemplateManager _templateMgr;

    static StatsCollector _statsCollector;

    static AccountDao _accountDao;
    static AccountVlanMapDao _accountVlanMapDao;
    static ClusterDao _clusterDao;
    static CapacityDao _capacityDao;
    static DiskOfferingDao _diskOfferingDao;
    static DiskOfferingJoinDao _diskOfferingJoinDao;
    static DataCenterJoinDao _dcJoinDao;
    static DomainDao _domainDao;
    static DomainRouterDao _domainRouterDao;
    static DomainRouterJoinDao _domainRouterJoinDao;
    static GuestOSDao _guestOSDao;
    static GuestOSCategoryDao _guestOSCategoryDao;
    static HostDao _hostDao;
    static AccountGuestVlanMapDao _accountGuestVlanMapDao;
    static IPAddressDao _ipAddressDao;
    static LoadBalancerDao _loadBalancerDao;
    static SecurityGroupDao _securityGroupDao;
    static SecurityGroupJoinDao _securityGroupJoinDao;
    static ServiceOfferingJoinDao _serviceOfferingJoinDao;
    static NetworkRuleConfigDao _networkRuleConfigDao;
    static HostPodDao _podDao;
    static ServiceOfferingDao _serviceOfferingDao;
    static SnapshotDao _snapshotDao;
    static PrimaryDataStoreDao _storagePoolDao;
    static VMTemplateDao _templateDao;
    static VMTemplateDetailsDao _templateDetailsDao;
    static VMTemplateHostDao _templateHostDao;
    static VMTemplateSwiftDao _templateSwiftDao;
    static VMTemplateS3Dao _templateS3Dao;
    static UploadDao _uploadDao;
    static UserDao _userDao;
    static UserStatisticsDao _userStatsDao;
    static UserVmDao _userVmDao;
    static UserVmJoinDao _userVmJoinDao;
    static VlanDao _vlanDao;
    static VolumeDao _volumeDao;
    static Site2SiteVpnGatewayDao _site2SiteVpnGatewayDao;
    static Site2SiteCustomerGatewayDao _site2SiteCustomerGatewayDao;
    static VolumeHostDao _volumeHostDao;
    static DataCenterDao _zoneDao;
    static NetworkOfferingDao _networkOfferingDao;
    static NetworkDao _networkDao;
    static PhysicalNetworkDao _physicalNetworkDao;
    static ConfigurationService _configMgr;
    static ConfigurationDao _configDao;
    static ConsoleProxyDao _consoleProxyDao;
    static FirewallRulesCidrsDao _firewallCidrsDao;
    static VMInstanceDao _vmDao;
    static ResourceLimitService _resourceLimitMgr;
    static ProjectService _projectMgr;
    static ResourceManager _resourceMgr;
    static AccountDetailsDao _accountDetailsDao;
    static NetworkDomainDao _networkDomainDao;
    static HighAvailabilityManager _haMgr;
    static VpcManager _vpcMgr;
    static TaggedResourceService _taggedResourceService;
    static UserVmDetailsDao _userVmDetailsDao;
    static SSHKeyPairDao _sshKeyPairDao;

    static ConditionDao _asConditionDao;
    static AutoScalePolicyConditionMapDao _asPolicyConditionMapDao;
    static AutoScaleVmGroupPolicyMapDao _asVmGroupPolicyMapDao;
    static AutoScalePolicyDao _asPolicyDao;
    static AutoScaleVmProfileDao _asVmProfileDao;
    static AutoScaleVmGroupDao _asVmGroupDao;
    static CounterDao _counterDao;
    static ResourceTagJoinDao _tagJoinDao;
    static EventJoinDao _eventJoinDao;
    static InstanceGroupJoinDao _vmGroupJoinDao;
    static UserAccountJoinDao _userAccountJoinDao;
    static ProjectJoinDao _projectJoinDao;
    static ProjectAccountJoinDao _projectAccountJoinDao;
    static ProjectInvitationJoinDao _projectInvitationJoinDao;
    static HostJoinDao _hostJoinDao;
    static VolumeJoinDao _volJoinDao;
    static StoragePoolJoinDao _poolJoinDao;
    static AccountJoinDao _accountJoinDao;
    static AsyncJobJoinDao _jobJoinDao;

    static PhysicalNetworkTrafficTypeDao _physicalNetworkTrafficTypeDao;
    static PhysicalNetworkServiceProviderDao _physicalNetworkServiceProviderDao;
    static FirewallRulesDao _firewallRuleDao;
    static StaticRouteDao _staticRouteDao;
    static VpcGatewayDao _vpcGatewayDao;
    static VpcDao _vpcDao;
    static VpcOfferingDao _vpcOfferingDao;
    static SnapshotPolicyDao _snapshotPolicyDao;
    static AsyncJobDao _asyncJobDao;
    static HostDetailsDao _hostDetailsDao;
    static VMSnapshotDao _vmSnapshotDao;
    static ClusterDetailsDao _clusterDetailsDao;
    static NicSecondaryIpDao _nicSecondaryIpDao;
    static VpcProvisioningService _vpcProvSvc;
    static AffinityGroupDao _affinityGroupDao;
    static AffinityGroupJoinDao _affinityGroupJoinDao;
    static GlobalLoadBalancingRulesService _gslbService;
    static NetworkACLDao _networkACLDao;

    @Inject private ManagementServer ms;
    @Inject public AsyncJobManager asyncMgr;
    @Inject private SecurityGroupManager securityGroupMgr;
    @Inject private StorageManager storageMgr;
    @Inject private UserVmManager userVmMgr;
    @Inject private NetworkModel networkModel;
    @Inject private NetworkManager networkMgr;
    @Inject private StatsCollector statsCollector;
    @Inject private TemplateManager templateMgr;
    @Inject private VolumeManager volumeMgr;

    @Inject private AccountDao accountDao;
    @Inject private AccountVlanMapDao accountVlanMapDao;
    @Inject private ClusterDao clusterDao;
    @Inject private CapacityDao capacityDao;
    @Inject private DataCenterJoinDao dcJoinDao;
    @Inject private DiskOfferingDao diskOfferingDao;
    @Inject private DiskOfferingJoinDao diskOfferingJoinDao;
    @Inject private DomainDao domainDao;
    @Inject private DomainRouterDao domainRouterDao;
    @Inject private DomainRouterJoinDao domainRouterJoinDao;
    @Inject private GuestOSDao guestOSDao;
    @Inject private GuestOSCategoryDao guestOSCategoryDao;
    @Inject private HostDao hostDao;
    @Inject private AccountGuestVlanMapDao accountGuestVlanMapDao;
    @Inject private IPAddressDao ipAddressDao;
    @Inject private LoadBalancerDao loadBalancerDao;
    @Inject private SecurityGroupDao securityGroupDao;
    @Inject private SecurityGroupJoinDao securityGroupJoinDao;
    @Inject private ServiceOfferingJoinDao serviceOfferingJoinDao;
    @Inject private NetworkRuleConfigDao networkRuleConfigDao;
    @Inject private HostPodDao podDao;
    @Inject private ServiceOfferingDao serviceOfferingDao;
    @Inject private SnapshotDao snapshotDao;
    @Inject private PrimaryDataStoreDao storagePoolDao;
    @Inject private VMTemplateDao templateDao;
    @Inject private VMTemplateDetailsDao templateDetailsDao;
    @Inject private VMTemplateHostDao templateHostDao;
    @Inject private VMTemplateSwiftDao templateSwiftDao;
    @Inject private VMTemplateS3Dao templateS3Dao;
    @Inject private UploadDao uploadDao;
    @Inject private UserDao userDao;
    @Inject private UserStatisticsDao userStatsDao;
    @Inject private UserVmDao userVmDao;
    @Inject private UserVmJoinDao userVmJoinDao;
    @Inject private VlanDao vlanDao;
    @Inject private VolumeDao volumeDao;
    @Inject private Site2SiteVpnGatewayDao site2SiteVpnGatewayDao;
    @Inject private Site2SiteCustomerGatewayDao site2SiteCustomerGatewayDao;
    @Inject private VolumeHostDao volumeHostDao;
    @Inject private DataCenterDao zoneDao;
    @Inject private NetworkOfferingDao networkOfferingDao;
    @Inject private NetworkDao networkDao;
    @Inject private PhysicalNetworkDao physicalNetworkDao;
    @Inject private ConfigurationService configMgr;
    @Inject private ConfigurationDao configDao;
    @Inject private ConsoleProxyDao consoleProxyDao;
    @Inject private FirewallRulesCidrsDao firewallCidrsDao;
    @Inject private VMInstanceDao vmDao;
    @Inject private ResourceLimitService resourceLimitMgr;
    @Inject private ProjectService projectMgr;
    @Inject private ResourceManager resourceMgr;
    @Inject private AccountDetailsDao accountDetailsDao;
    @Inject private NetworkDomainDao networkDomainDao;
    @Inject private HighAvailabilityManager haMgr;
    @Inject private VpcManager vpcMgr;
    @Inject private TaggedResourceService taggedResourceService;
    @Inject private UserVmDetailsDao userVmDetailsDao;
    @Inject private SSHKeyPairDao sshKeyPairDao;

    @Inject private ConditionDao asConditionDao;
    @Inject private AutoScalePolicyConditionMapDao asPolicyConditionMapDao;
    @Inject private AutoScaleVmGroupPolicyMapDao asVmGroupPolicyMapDao;
    @Inject private AutoScalePolicyDao asPolicyDao;
    @Inject private AutoScaleVmProfileDao asVmProfileDao;
    @Inject private AutoScaleVmGroupDao asVmGroupDao;
    @Inject private CounterDao counterDao;
    @Inject private ResourceTagJoinDao tagJoinDao;
    @Inject private EventJoinDao eventJoinDao;
    @Inject private InstanceGroupJoinDao vmGroupJoinDao;
    @Inject private UserAccountJoinDao userAccountJoinDao;
    @Inject private ProjectJoinDao projectJoinDao;
    @Inject private ProjectAccountJoinDao projectAccountJoinDao;
    @Inject private ProjectInvitationJoinDao projectInvitationJoinDao;
    @Inject private HostJoinDao hostJoinDao;
    @Inject private VolumeJoinDao volJoinDao;
    @Inject private StoragePoolJoinDao poolJoinDao;
    @Inject private AccountJoinDao accountJoinDao;
    @Inject private AsyncJobJoinDao jobJoinDao;

    @Inject private PhysicalNetworkTrafficTypeDao physicalNetworkTrafficTypeDao;
    @Inject private PhysicalNetworkServiceProviderDao physicalNetworkServiceProviderDao;
    @Inject private FirewallRulesDao firewallRuleDao;
    @Inject private StaticRouteDao staticRouteDao;
    @Inject private VpcGatewayDao vpcGatewayDao;
    @Inject private VpcDao vpcDao;
    @Inject private VpcOfferingDao vpcOfferingDao;
    @Inject private SnapshotPolicyDao snapshotPolicyDao;
    @Inject private AsyncJobDao asyncJobDao;
    @Inject private HostDetailsDao hostDetailsDao;
    @Inject private ClusterDetailsDao clusterDetailsDao;
    @Inject private VMSnapshotDao vmSnapshotDao;
    @Inject private NicSecondaryIpDao nicSecondaryIpDao;
    @Inject private VpcProvisioningService vpcProvSvc;
    @Inject private ApplicationLoadBalancerRuleDao _appLbDao;
    @Inject private AffinityGroupDao affinityGroupDao;
    @Inject private AffinityGroupJoinDao affinityGroupJoinDao;
    @Inject private GlobalLoadBalancingRulesService gslbService;
    @Inject private NetworkACLDao networkACLDao;

    @PostConstruct
    void init() {
        _ms = ms;
        _asyncMgr = asyncMgr;
        _securityGroupMgr = securityGroupMgr;
        _storageMgr = storageMgr;
        _userVmMgr = userVmMgr;
        _networkModel = networkModel;
        _networkMgr = networkMgr;
        _configMgr = configMgr;
        _templateMgr = templateMgr;

        _accountDao = accountDao;
        _accountGuestVlanMapDao = accountGuestVlanMapDao;
        _accountVlanMapDao = accountVlanMapDao;
        _clusterDao = clusterDao;
        _capacityDao = capacityDao;
        _dcJoinDao = dcJoinDao;
        _diskOfferingDao = diskOfferingDao;
        _diskOfferingJoinDao = diskOfferingJoinDao;
        _domainDao = domainDao;
        _domainRouterDao = domainRouterDao;
        _domainRouterJoinDao = domainRouterJoinDao;
        _guestOSDao = guestOSDao;
        _guestOSCategoryDao = guestOSCategoryDao;
        _hostDao = hostDao;
        _ipAddressDao = ipAddressDao;
        _loadBalancerDao = loadBalancerDao;
        _networkRuleConfigDao = networkRuleConfigDao;
        _podDao = podDao;
        _serviceOfferingDao = serviceOfferingDao;
        _serviceOfferingJoinDao = serviceOfferingJoinDao;
        _snapshotDao = snapshotDao;
        _storagePoolDao = storagePoolDao;
        _templateDao = templateDao;
        _templateDetailsDao = templateDetailsDao;
        _templateHostDao = templateHostDao;
        _templateSwiftDao = templateSwiftDao;
        _templateS3Dao = templateS3Dao;
        _uploadDao = uploadDao;
        _userDao = userDao;
        _userStatsDao = userStatsDao;
        _userVmDao = userVmDao;
        _userVmJoinDao = userVmJoinDao;
        _vlanDao = vlanDao;
        _volumeDao = volumeDao;
        _site2SiteVpnGatewayDao = site2SiteVpnGatewayDao;
        _site2SiteCustomerGatewayDao = site2SiteCustomerGatewayDao;
        _volumeHostDao = volumeHostDao;
        _zoneDao = zoneDao;
        _securityGroupDao = securityGroupDao;
        _securityGroupJoinDao = securityGroupJoinDao;
        _networkOfferingDao = networkOfferingDao;
        _networkDao = networkDao;
        _physicalNetworkDao = physicalNetworkDao;
        _configDao = configDao;
        _consoleProxyDao = consoleProxyDao;
        _firewallCidrsDao = firewallCidrsDao;
        _vmDao = vmDao;
        _resourceLimitMgr = resourceLimitMgr;
        _projectMgr = projectMgr;
        _resourceMgr = resourceMgr;
        _accountDetailsDao = accountDetailsDao;
        _networkDomainDao = networkDomainDao;
        _haMgr = haMgr;
        _vpcMgr = vpcMgr;
        _taggedResourceService = taggedResourceService;
        _sshKeyPairDao = sshKeyPairDao;
        _userVmDetailsDao = userVmDetailsDao;
        _asConditionDao = asConditionDao;
        _asPolicyDao = asPolicyDao;
        _asPolicyConditionMapDao = asPolicyConditionMapDao;
        _counterDao = counterDao;
        _asVmGroupPolicyMapDao = asVmGroupPolicyMapDao;
        _tagJoinDao = tagJoinDao;
        _vmGroupJoinDao = vmGroupJoinDao;
        _eventJoinDao = eventJoinDao;
        _userAccountJoinDao = userAccountJoinDao;
        _projectJoinDao = projectJoinDao;
        _projectAccountJoinDao = projectAccountJoinDao;
        _projectInvitationJoinDao = projectInvitationJoinDao;
        _hostJoinDao = hostJoinDao;
        _volJoinDao = volJoinDao;
        _poolJoinDao = poolJoinDao;
        _accountJoinDao = accountJoinDao;
        _jobJoinDao = jobJoinDao;

        _physicalNetworkTrafficTypeDao = physicalNetworkTrafficTypeDao;
        _physicalNetworkServiceProviderDao = physicalNetworkServiceProviderDao;
        _firewallRuleDao = firewallRuleDao;
        _staticRouteDao = staticRouteDao;
        _vpcGatewayDao = vpcGatewayDao;
        _asVmProfileDao = asVmProfileDao;
        _asVmGroupDao = asVmGroupDao;
        _vpcDao = vpcDao;
        _vpcOfferingDao = vpcOfferingDao;
        _snapshotPolicyDao = snapshotPolicyDao;
        _asyncJobDao = asyncJobDao;
        _hostDetailsDao = hostDetailsDao;
        _clusterDetailsDao = clusterDetailsDao;
        _vmSnapshotDao = vmSnapshotDao;
        _nicSecondaryIpDao = nicSecondaryIpDao;
        _vpcProvSvc = vpcProvSvc;
        _affinityGroupDao = affinityGroupDao;
        _affinityGroupJoinDao = affinityGroupJoinDao;
        _gslbService = gslbService;
        // Note: stats collector should already have been initialized by this time, otherwise a null instance is returned
        _statsCollector = StatsCollector.getInstance();
        _networkACLDao = networkACLDao;
    }

    // ///////////////////////////////////////////////////////////
    // ManagementServer methods //
    // ///////////////////////////////////////////////////////////

    public static VMInstanceVO findVMInstanceById(long vmId) {
        return _vmDao.findById(vmId);
    }

    public static long getMemoryOrCpuCapacitybyHost(Long hostId, short capacityType) {
        // TODO: This method is for the API only, but it has configuration values (ramSize for system vms)
        // so if this Utils class can have some kind of config rather than a static initializer (maybe from
        // management server instantiation?) then maybe the management server method can be moved entirely
        // into this utils class.
        return _ms.getMemoryOrCpuCapacityByHost(hostId,capacityType);
    }

    public static long getStorageCapacitybyPool(Long poolId, short capacityType) {
        // TODO: This method is for the API only, but it has configuration values (ramSize for system vms)
        // so if this Utils class can have some kind of config rather than a static initializer (maybe from
        // management server instantiation?) then maybe the management server method can be moved entirely
        // into this utils class.
        return _ms.getMemoryOrCpuCapacityByHost(poolId, capacityType);
    }

    public static List<SummedCapacity> getCapacityByClusterPodZone(Long zoneId, Long podId, Long clusterId){
        return _capacityDao.findByClusterPodZone(zoneId,podId,clusterId);
    }

    public static List<SummedCapacity> findNonSharedStorageForClusterPodZone(Long zoneId, Long podId, Long clusterId){
        return _capacityDao.findNonSharedStorageForClusterPodZone(zoneId,podId,clusterId);
    }

    public static List<CapacityVO> getCapacityByPod(){
        return null;

    }

    public static Long getPodIdForVlan(long vlanDbId) {
        return _networkModel.getPodIdForVlan(vlanDbId);
    }

    public static String getVersion() {
        return _ms.getVersion();
    }

    public static List<UserVmJoinVO> searchForUserVMs(Criteria c, List<Long> permittedAccounts) {
        return _userVmMgr.searchForUserVMs(c, _accountDao.findById(Account.ACCOUNT_ID_SYSTEM),
                null, false, permittedAccounts, false, null, null).first();
    }

    public static List<? extends StoragePoolVO> searchForStoragePools(Criteria c) {
        return _ms.searchForStoragePools(c).first();
    }

    // ///////////////////////////////////////////////////////////
    // Manager methods //
    // ///////////////////////////////////////////////////////////

    public static long findCorrectResourceLimit(ResourceType type, long accountId) {
        AccountVO account = _accountDao.findById(accountId);

        if (account == null) {
            return -1;
        }

        return _resourceLimitMgr.findCorrectResourceLimitForAccount(account, type);
    }

    public static long findCorrectResourceLimit(Long limit, short accountType, ResourceType type) {
        return _resourceLimitMgr.findCorrectResourceLimitForAccount(accountType, limit, type);
    }

    public static AsyncJobVO findInstancePendingAsyncJob(String instanceType, long instanceId) {
        return _asyncMgr.findInstancePendingAsyncJob(instanceType, instanceId);
    }

    public static long getResourceCount(ResourceType type, long accountId) {
        AccountVO account = _accountDao.findById(accountId);

        if (account == null) {
            return -1;
        }

        return _resourceLimitMgr.getResourceCount(account, type);
    }

    public static String getSecurityGroupsNamesForVm(long vmId) {
        return _securityGroupMgr.getSecurityGroupsNamesForVm(vmId);
    }

    public static List<SecurityGroupVO> getSecurityGroupsForVm(long vmId) {
        return _securityGroupMgr.getSecurityGroupsForVm(vmId);
    }

    public static String getSnapshotIntervalTypes(long snapshotId) {
        SnapshotVO snapshot = _snapshotDao.findById(snapshotId);
        return snapshot.getRecurringType().name();
    }

    public static String getStoragePoolTags(long poolId) {
        return _storageMgr.getStoragePoolTags(poolId);
    }

    public static boolean isLocalStorageActiveOnHost(Long hostId) {
        return _storageMgr.isLocalStorageActiveOnHost(hostId);
    }

    public static InstanceGroupVO findInstanceGroupForVM(long vmId) {
        return _userVmMgr.getGroupForVm(vmId);
    }

    // ///////////////////////////////////////////////////////////
    // Misc methods //
    // ///////////////////////////////////////////////////////////

    public static HostStats getHostStatistics(long hostId) {
        return _statsCollector.getHostStats(hostId);
    }

    public static StorageStats getStoragePoolStatistics(long id) {
        return _statsCollector.getStoragePoolStats(id);
    }

    public static VmStats getVmStatistics(long hostId) {
        return _statsCollector.getVmStats(hostId);
    }

    public static StorageStats getSecondaryStorageStatistics(long id) {
        return _statsCollector.getStorageStats(id);
    }

    public static CapacityVO getStoragePoolUsedStats(Long poolId, Long clusterId, Long podId, Long zoneId){
        return _storageMgr.getStoragePoolUsedStats(poolId, clusterId, podId, zoneId);
    }

    public static CapacityVO getSecondaryStorageUsedStats(Long hostId, Long zoneId){
        return _storageMgr.getSecondaryStorageUsedStats(hostId, zoneId);
    }

    // ///////////////////////////////////////////////////////////
    // Dao methods //
    // ///////////////////////////////////////////////////////////

    public static Account findAccountById(Long accountId) {
        return _accountDao.findByIdIncludingRemoved(accountId);
    }

    public static Account findAccountByIdIncludingRemoved(Long accountId) {
        return _accountDao.findByIdIncludingRemoved(accountId);
    }

    public static Account findAccountByNameDomain(String accountName, Long domainId) {
        return _accountDao.findActiveAccount(accountName, domainId);
    }

    public static ClusterVO findClusterById(long clusterId) {
        return _clusterDao.findById(clusterId);
    }

    public static ClusterDetailsVO findClusterDetails(long clusterId, String name){
         return _clusterDetailsDao.findDetail(clusterId,name);
    }

    public static DiskOfferingVO findDiskOfferingById(Long diskOfferingId) {
        return _diskOfferingDao.findByIdIncludingRemoved(diskOfferingId);
    }

    public static DomainVO findDomainById(Long domainId) {
        return _domainDao.findByIdIncludingRemoved(domainId);
    }

    public static DomainVO findDomainByIdIncludingRemoved(Long domainId) {
        return _domainDao.findByIdIncludingRemoved(domainId);
    }

    public static boolean isChildDomain(long parentId, long childId) {
        return _domainDao.isChildDomain(parentId, childId);
    }

    public static DomainRouterVO findDomainRouterById(Long routerId) {
        return _domainRouterDao.findByIdIncludingRemoved(routerId);
    }

    public static GuestOS findGuestOSById(Long id) {
        return _guestOSDao.findByIdIncludingRemoved(id);
    }

    public static GuestOS findGuestOSByDisplayName(String displayName) {
        return _guestOSDao.listByDisplayName(displayName);
    }

    public static HostVO findHostById(Long hostId) {
        return _hostDao.findByIdIncludingRemoved(hostId);
    }

    public static IPAddressVO findIpAddressById(long addressId) {
        return _ipAddressDao.findById(addressId);
    }

    public static GuestOSCategoryVO getHostGuestOSCategory(long hostId) {
        Long guestOSCategoryID = _resourceMgr.getGuestOSCategoryId(hostId);

        if (guestOSCategoryID != null) {
            return _guestOSCategoryDao.findById(guestOSCategoryID);
        } else {
            return null;
        }
    }

    public static String getHostTags(long hostId) {
        return _resourceMgr.getHostTags(hostId);
    }

    public static LoadBalancerVO findLoadBalancerById(Long loadBalancerId) {
        return _loadBalancerDao.findById(loadBalancerId);
    }

    public static NetworkRuleConfigVO findNetworkRuleById(Long ruleId) {
        return _networkRuleConfigDao.findById(ruleId);
    }

    public static SecurityGroup findSecurityGroupById(Long groupId) {
        return _securityGroupDao.findById(groupId);
    }

    public static HostPodVO findPodById(Long podId) {
        return _podDao.findById(podId);
    }

    public static VolumeVO findRootVolume(long vmId) {
        List<VolumeVO> volumes = _volumeDao.findByInstanceAndType(vmId, Type.ROOT);
        if (volumes != null && volumes.size() == 1) {
            return volumes.get(0);
        } else {
            return null;
        }
    }

    public static ServiceOffering findServiceOfferingById(Long serviceOfferingId) {
        return _serviceOfferingDao.findByIdIncludingRemoved(serviceOfferingId);
    }

    public static Snapshot findSnapshotById(long snapshotId) {
        SnapshotVO snapshot = _snapshotDao.findById(snapshotId);
        if (snapshot != null && snapshot.getRemoved() == null && snapshot.getState() == Snapshot.State.BackedUp) {
            return snapshot;
        } else {
            return null;
        }
    }

    public static StoragePoolVO findStoragePoolById(Long storagePoolId) {
        return _storagePoolDao.findByIdIncludingRemoved(storagePoolId);
    }

    public static VMTemplateVO findTemplateById(Long templateId) {
        VMTemplateVO template = _templateDao.findByIdIncludingRemoved(templateId);
        if(template != null) {
            Map details = _templateDetailsDao.findDetails(templateId);
            if(details != null && !details.isEmpty())
                template.setDetails(details);
        }
        return template;
    }

    public static VMTemplateHostVO findTemplateHostRef(long templateId, long zoneId) {
        return findTemplateHostRef(templateId, zoneId, false);
    }

    public static VMTemplateHostVO findTemplateHostRef(long templateId, long zoneId, boolean readyOnly) {
        VMTemplateVO vmTemplate = findTemplateById(templateId);
        if (vmTemplate.getHypervisorType() == HypervisorType.BareMetal) {
            List<VMTemplateHostVO> res = _templateHostDao.listByTemplateId(templateId);
            return res.size() == 0 ? null : res.get(0);
        } else {
            return _templateMgr.getTemplateHostRef(zoneId, templateId, readyOnly);
        }
    }


    public static VolumeHostVO findVolumeHostRef(long volumeId, long zoneId) {
        return _volumeHostDao.findVolumeByZone(volumeId, zoneId);
    }

    public static VMTemplateSwiftVO findTemplateSwiftRef(long templateId) {
        return _templateSwiftDao.findOneByTemplateId(templateId);
    }

    public static VMTemplateS3VO findTemplateS3Ref(long templateId) {
        return _templateS3Dao.findOneByTemplateId(templateId);
    }

    public static UploadVO findUploadById(Long id) {
        return _uploadDao.findById(id);
    }

    public static User findUserById(Long userId) {
        return _userDao.findById(userId);
    }

    public static UserVm findUserVmById(Long vmId) {
        return _userVmDao.findById(vmId);
    }

    public static VlanVO findVlanById(long vlanDbId) {
        return _vlanDao.findById(vlanDbId);
    }

    public static VolumeVO findVolumeById(Long volumeId) {
        return _volumeDao.findByIdIncludingRemoved(volumeId);
    }

    public static Site2SiteVpnGatewayVO findVpnGatewayById(Long vpnGatewayId) {
        return _site2SiteVpnGatewayDao.findById(vpnGatewayId);
    }

    public static Site2SiteCustomerGatewayVO findCustomerGatewayById(Long customerGatewayId) {
        return _site2SiteCustomerGatewayDao.findById(customerGatewayId);
    }

    public static List<UserVO> listUsersByAccount(long accountId) {
        return _userDao.listByAccount(accountId);
    }

    public static DataCenterVO findZoneById(Long zoneId) {
        return _zoneDao.findById(zoneId);
    }

    public static Long getAccountIdForVlan(long vlanDbId) {
        List<AccountVlanMapVO> accountVlanMaps = _accountVlanMapDao.listAccountVlanMapsByVlan(vlanDbId);
        if (accountVlanMaps.isEmpty()) {
            return null;
        } else {
            return accountVlanMaps.get(0).getAccountId();
        }
    }

    public static Long getAccountIdForGuestVlan(long vlanDbId) {
        List<AccountGuestVlanMapVO> accountGuestVlanMaps = _accountGuestVlanMapDao.listAccountGuestVlanMapsByVlan(vlanDbId);
        if (accountGuestVlanMaps.isEmpty()) {
            return null;
        } else {
            return accountGuestVlanMaps.get(0).getAccountId();
        }
    }

    public static HypervisorType getVolumeHyperType(long volumeId) {
        return _volumeDao.getHypervisorType(volumeId);
    }

    public static HypervisorType getHypervisorTypeFromFormat(ImageFormat format){
        return _storageMgr.getHypervisorTypeFromFormat(format);
    }

    public static List<VMTemplateHostVO> listTemplateHostBy(long templateId, Long zoneId, boolean readyOnly) {
        if (zoneId != null) {
            VMTemplateVO vmTemplate = findTemplateById(templateId);
            if (vmTemplate.getHypervisorType() == HypervisorType.BareMetal) {
                return _templateHostDao.listByTemplateId(templateId);
            } else {
                return _templateHostDao.listByZoneTemplate(zoneId, templateId, readyOnly);
            }
        } else {
            return _templateHostDao.listByOnlyTemplateId(templateId);
        }
    }

    public static List<UserStatisticsVO> listUserStatsBy(Long accountId) {
        return _userStatsDao.listBy(accountId);
    }

    public static List<UserVmVO> listUserVMsByHostId(long hostId) {
        return _userVmDao.listByHostId(hostId);
    }

    public static List<DataCenterVO> listZones() {
        return _zoneDao.listAll();
    }

    public static boolean volumeIsOnSharedStorage(long volumeId) {
        // Check that the volume is valid
        VolumeVO volume = _volumeDao.findById(volumeId);
        if (volume == null) {
            throw new InvalidParameterValueException("Please specify a valid volume ID.");
        }

        return _volumeMgr.volumeOnSharedStoragePool(volume);
    }

    public static List<NicProfile> getNics(VirtualMachine vm) {
        return _networkMgr.getNicProfiles(vm);
    }

    public static NetworkProfile getNetworkProfile(long networkId) {
        return _networkMgr.convertNetworkToNetworkProfile(networkId);
    }

    public static NetworkOfferingVO findNetworkOfferingById(long networkOfferingId) {
        return _networkOfferingDao.findByIdIncludingRemoved(networkOfferingId);
    }

    public static List<? extends Vlan> listVlanByNetworkId(long networkId) {
        return _vlanDao.listVlansByNetworkId(networkId);
    }

    public static PhysicalNetworkVO findPhysicalNetworkById(long id) {
        return _physicalNetworkDao.findById(id);
    }

    public static PhysicalNetworkTrafficTypeVO findPhysicalNetworkTrafficTypeById(long id) {
        return _physicalNetworkTrafficTypeDao.findById(id);
    }

    public static NetworkVO findNetworkById(long id) {
        return _networkDao.findById(id);
    }

    public static Map<Service, Map<Capability, String>> getNetworkCapabilities(long networkId, long zoneId) {
        return _networkModel.getNetworkCapabilities(networkId);
    }

    public static long getPublicNetworkIdByZone(long zoneId) {
        return _networkModel.getSystemNetworkByZoneAndTrafficType(zoneId, TrafficType.Public).getId();
    }

    public static Long getVlanNetworkId(long vlanId) {
        VlanVO vlan = _vlanDao.findById(vlanId);
        if (vlan != null) {
            return vlan.getNetworkId();
        } else {
            return null;
        }
    }

    public static Integer getNetworkRate(long networkOfferingId) {
        return _configMgr.getNetworkOfferingNetworkRate(networkOfferingId, null);
    }

    public static Account getVlanAccount(long vlanId) {
        return _configMgr.getVlanAccount(vlanId);
    }

    public static boolean isSecurityGroupEnabledInZone(long zoneId) {
        DataCenterVO dc = _zoneDao.findById(zoneId);
        if (dc == null) {
            return false;
        } else {
            return dc.isSecurityGroupEnabled();
        }
    }

    public static Long getDedicatedNetworkDomain(long networkId) {
        return _networkModel.getDedicatedNetworkDomain(networkId);
    }

    public static float getCpuOverprovisioningFactor() {
        String opFactor = _configDao.getValue(Config.CPUOverprovisioningFactor.key());
        float cpuOverprovisioningFactor = NumbersUtil.parseFloat(opFactor, 1);
        return cpuOverprovisioningFactor;
    }

    public static boolean isExtractionDisabled(){
        String disableExtractionString = _configDao.getValue(Config.DisableExtraction.toString());
        boolean disableExtraction  = (disableExtractionString == null) ? false : Boolean.parseBoolean(disableExtractionString);
        return disableExtraction;
    }

    public static SecurityGroup getSecurityGroup(String groupName, long ownerId) {
        return _securityGroupMgr.getSecurityGroup(groupName, ownerId);
    }

    public static ConsoleProxyVO findConsoleProxy(long id) {
        return _consoleProxyDao.findById(id);
    }

    public static List<String> findFirewallSourceCidrs(long id){
        return _firewallCidrsDao.getSourceCidrs(id);
    }

    public static Account getProjectOwner(long projectId) {
        return _projectMgr.getProjectOwner(projectId);
    }

    public static Project findProjectByProjectAccountId(long projectAccountId) {
        return _projectMgr.findByProjectAccountId(projectAccountId);
    }

    public static Project findProjectByProjectAccountIdIncludingRemoved(long projectAccountId) {
        return _projectMgr.findByProjectAccountIdIncludingRemoved(projectAccountId);
    }

    public static Project findProjectById(long projectId) {
        return _projectMgr.getProject(projectId);
    }

    public static long getProjectOwnwerId(long projectId) {
        return _projectMgr.getProjectOwner(projectId).getId();
    }

    public static Map<String, String> getAccountDetails(long accountId) {
        Map<String, String> details = _accountDetailsDao.findDetails(accountId);
        return details.isEmpty() ? null : details;
    }

    public static Map<Service, Set<Provider>> listNetworkOfferingServices(long networkOfferingId) {
        return _networkModel.getNetworkOfferingServiceProvidersMap(networkOfferingId);
    }

    public static List<Service> getElementServices(Provider provider) {
        return _networkModel.getElementServices(provider);
    }

    public static List<? extends Provider> getProvidersForService(Service service) {
        return _networkModel.listSupportedNetworkServiceProviders(service.getName());
    }

    public static boolean canElementEnableIndividualServices(Provider serviceProvider) {
        return _networkModel.canElementEnableIndividualServices(serviceProvider);
    }

    public static Pair<Long, Boolean> getDomainNetworkDetails(long networkId) {
        NetworkDomainVO map = _networkDomainDao.getDomainNetworkMapByNetworkId(networkId);

        boolean subdomainAccess = (map.isSubdomainAccess() != null) ? map.isSubdomainAccess() : _networkModel.getAllowSubdomainAccessGlobal();

        return new Pair<Long, Boolean>(map.getDomainId(), subdomainAccess);
    }

    public static long countFreePublicIps() {
        return _ipAddressDao.countFreePublicIPs();
    }

    public static long findDefaultRouterServiceOffering() {
        ServiceOfferingVO serviceOffering = _serviceOfferingDao.findByName(ServiceOffering.routerDefaultOffUniqueName);
        return serviceOffering.getId();
    }

    public static IpAddress findIpByAssociatedVmId(long vmId) {
        return _ipAddressDao.findByAssociatedVmId(vmId);
    }

    public static String getHaTag() {
        return _haMgr.getHaTag();
    }

    public static Map<Service, Set<Provider>> listVpcOffServices(long vpcOffId) {
        return _vpcMgr.getVpcOffSvcProvidersMap(vpcOffId);
    }

    public static List<? extends Network> listVpcNetworks(long vpcId) {
        return _networkModel.listNetworksByVpc(vpcId);
    }

    public static boolean canUseForDeploy(Network network) {
        return _networkModel.canUseForDeploy(network);
    }

    public static VMSnapshot getVMSnapshotById(Long vmSnapshotId) {
        VMSnapshot vmSnapshot = _vmSnapshotDao.findById(vmSnapshotId);
        return vmSnapshot;
    }

    public static String getUuid(String resourceId, TaggedResourceType resourceType) {
        return _taggedResourceService.getUuid(resourceId, resourceType);
    }

    public static boolean isOfferingForVpc(NetworkOffering offering) {
        boolean vpcProvider = _configMgr.isOfferingForVpc(offering);
        return vpcProvider;
    }

    public static List<? extends ResourceTag> listByResourceTypeAndId(TaggedResourceType type, long resourceId) {
        return _taggedResourceService.listByResourceTypeAndId(type, resourceId);
    }
    public static List<ConditionVO> getAutoScalePolicyConditions(long policyId)
    {
        List<AutoScalePolicyConditionMapVO> vos = _asPolicyConditionMapDao.listByAll(policyId, null);
        ArrayList<ConditionVO> conditions = new ArrayList<ConditionVO>(vos.size());
        for (AutoScalePolicyConditionMapVO vo : vos) {
            conditions.add(_asConditionDao.findById(vo.getConditionId()));
        }

        return conditions;
    }

    public static void getAutoScaleVmGroupPolicyIds(long vmGroupId, List<Long> scaleUpPolicyIds, List<Long> scaleDownPolicyIds)
    {
        List<AutoScaleVmGroupPolicyMapVO> vos = _asVmGroupPolicyMapDao.listByVmGroupId(vmGroupId);
        for (AutoScaleVmGroupPolicyMapVO vo : vos) {
            AutoScalePolicy autoScalePolicy = _asPolicyDao.findById(vo.getPolicyId());
            if(autoScalePolicy.getAction().equals("scaleup"))
                scaleUpPolicyIds.add(autoScalePolicy.getId());
            else
                scaleDownPolicyIds.add(autoScalePolicy.getId());
        }
    }
    public static String getKeyPairName(String sshPublicKey) {
        SSHKeyPairVO sshKeyPair = _sshKeyPairDao.findByPublicKey(sshPublicKey);
        //key might be removed prior to this point
        if (sshKeyPair != null) {
            return sshKeyPair.getName();
        }
        return null;
    }

    public static UserVmDetailVO  findPublicKeyByVmId(long vmId) {
        return _userVmDetailsDao.findDetail(vmId, "SSH.PublicKey");
    }

    public static void getAutoScaleVmGroupPolicies(long vmGroupId, List<AutoScalePolicy> scaleUpPolicies, List<AutoScalePolicy> scaleDownPolicies)
    {
        List<AutoScaleVmGroupPolicyMapVO> vos = _asVmGroupPolicyMapDao.listByVmGroupId(vmGroupId);
        for (AutoScaleVmGroupPolicyMapVO vo : vos) {
            AutoScalePolicy autoScalePolicy = _asPolicyDao.findById(vo.getPolicyId());
            if(autoScalePolicy.getAction().equals("scaleup"))
                scaleUpPolicies.add(autoScalePolicy);
            else
                scaleDownPolicies.add(autoScalePolicy);
        }
    }

    public static CounterVO getCounter(long counterId) {
        return _counterDao.findById(counterId);
    }

    public static ConditionVO findConditionById(long conditionId){
        return _asConditionDao.findById(conditionId);
    }

    public static PhysicalNetworkServiceProviderVO findPhysicalNetworkServiceProviderById(long providerId){
        return _physicalNetworkServiceProviderDao.findById(providerId);
    }

    public static FirewallRuleVO findFirewallRuleById(long ruleId){
        return _firewallRuleDao.findById(ruleId);
    }

    public static StaticRouteVO findStaticRouteById(long routeId){
        return _staticRouteDao.findById(routeId);
    }

    public static VpcGatewayVO findVpcGatewayById(long gatewayId){
        return _vpcGatewayDao.findById(gatewayId);
    }

    public static AutoScalePolicyVO findAutoScalePolicyById(long policyId){
        return _asPolicyDao.findById(policyId);
    }

    public static AutoScaleVmProfileVO findAutoScaleVmProfileById(long profileId){
        return _asVmProfileDao.findById(profileId);
    }

    public static AutoScaleVmGroupVO findAutoScaleVmGroupById(long groupId){
        return _asVmGroupDao.findById(groupId);
    }

    public static GuestOSCategoryVO findGuestOsCategoryById(long catId){
        return _guestOSCategoryDao.findById(catId);
    }

    public static VpcVO findVpcById(long vpcId){
        return _vpcDao.findById(vpcId);
    }

    public static SnapshotPolicy findSnapshotPolicyById(long policyId){
        return _snapshotPolicyDao.findById(policyId);
    }

    public static VpcOffering findVpcOfferingById(long offeringId){
        return _vpcOfferingDao.findById(offeringId);
    }

    public static NetworkACL findByNetworkACLId(long aclId){
        return _networkACLDao.findById(aclId);
    }

    public static AsyncJob findAsyncJobById(long jobId){
        return _asyncJobDao.findById(jobId);
    }

    public static String findJobInstanceUuid(AsyncJob job){
        if ( job == null )
            return null;
        String jobInstanceId = null;
        if (job.getInstanceType() == AsyncJob.Type.Volume) {
            VolumeVO volume = ApiDBUtils.findVolumeById(job.getInstanceId());
            if (volume != null) {
                jobInstanceId = volume.getUuid();
            }
        } else if (job.getInstanceType() == AsyncJob.Type.Template || job.getInstanceType() == AsyncJob.Type.Iso) {
            VMTemplateVO template = ApiDBUtils.findTemplateById(job.getInstanceId());
            if (template != null) {
                jobInstanceId = template.getUuid();
            }
        } else if (job.getInstanceType() == AsyncJob.Type.VirtualMachine || job.getInstanceType() == AsyncJob.Type.ConsoleProxy
                || job.getInstanceType() == AsyncJob.Type.SystemVm || job.getInstanceType() == AsyncJob.Type.DomainRouter) {
            VMInstanceVO vm = ApiDBUtils.findVMInstanceById(job.getInstanceId());
            if (vm != null) {
                jobInstanceId = vm.getUuid();
            }
        } else if (job.getInstanceType() == AsyncJob.Type.Snapshot) {
            Snapshot snapshot = ApiDBUtils.findSnapshotById(job.getInstanceId());
            if (snapshot != null) {
                jobInstanceId = snapshot.getUuid();
            }
        } else if (job.getInstanceType() == AsyncJob.Type.Host) {
            Host host = ApiDBUtils.findHostById(job.getInstanceId());
            if (host != null) {
                jobInstanceId = host.getUuid();
            }
        } else if (job.getInstanceType() == AsyncJob.Type.StoragePool) {
            StoragePoolVO spool = ApiDBUtils.findStoragePoolById(job.getInstanceId());
            if (spool != null) {
                jobInstanceId = spool.getUuid();
            }
        } else if (job.getInstanceType() == AsyncJob.Type.IpAddress) {
            IPAddressVO ip = ApiDBUtils.findIpAddressById(job.getInstanceId());
            if (ip != null) {
                jobInstanceId = ip.getUuid();
            }
        } else if (job.getInstanceType() == AsyncJob.Type.SecurityGroup) {
            SecurityGroup sg = ApiDBUtils.findSecurityGroupById(job.getInstanceId());
            if (sg != null) {
                jobInstanceId = sg.getUuid();
            }
        } else if (job.getInstanceType() == AsyncJob.Type.PhysicalNetwork) {
            PhysicalNetworkVO pnet = ApiDBUtils.findPhysicalNetworkById(job.getInstanceId());
            if (pnet != null) {
                jobInstanceId = pnet.getUuid();
            }
        } else if (job.getInstanceType() == AsyncJob.Type.TrafficType) {
            PhysicalNetworkTrafficTypeVO trafficType = ApiDBUtils.findPhysicalNetworkTrafficTypeById(job.getInstanceId());
            if (trafficType != null) {
                jobInstanceId = trafficType.getUuid();
            }
        } else if (job.getInstanceType() == AsyncJob.Type.PhysicalNetworkServiceProvider) {
            PhysicalNetworkServiceProvider sp = ApiDBUtils.findPhysicalNetworkServiceProviderById(job.getInstanceId());
            if (sp != null) {
                jobInstanceId = sp.getUuid();
            }
        } else if (job.getInstanceType() == AsyncJob.Type.FirewallRule) {
            FirewallRuleVO fw = ApiDBUtils.findFirewallRuleById(job.getInstanceId());
            if (fw != null) {
                jobInstanceId = fw.getUuid();
            }
        } else if (job.getInstanceType() == AsyncJob.Type.Account) {
            Account acct = ApiDBUtils.findAccountById(job.getInstanceId());
            if (acct != null) {
                jobInstanceId = acct.getUuid();
            }
        } else if (job.getInstanceType() == AsyncJob.Type.User) {
            User usr = ApiDBUtils.findUserById(job.getInstanceId());
            if (usr != null) {
                jobInstanceId = usr.getUuid();
            }
        } else if (job.getInstanceType() == AsyncJob.Type.StaticRoute) {
            StaticRouteVO route = ApiDBUtils.findStaticRouteById(job.getInstanceId());
            if (route != null) {
                jobInstanceId = route.getUuid();
            }
        } else if (job.getInstanceType() == AsyncJob.Type.PrivateGateway) {
            VpcGatewayVO gateway = ApiDBUtils.findVpcGatewayById(job.getInstanceId());
            if (gateway != null) {
                jobInstanceId = gateway.getUuid();
            }
        } else if (job.getInstanceType() == AsyncJob.Type.Counter) {
            CounterVO counter = ApiDBUtils.getCounter(job.getInstanceId());
            if (counter != null) {
                jobInstanceId = counter.getUuid();
            }
        } else if (job.getInstanceType() == AsyncJob.Type.Condition) {
            ConditionVO condition = ApiDBUtils.findConditionById(job.getInstanceId());
            if (condition != null) {
                jobInstanceId = condition.getUuid();
            }
        } else if (job.getInstanceType() == AsyncJob.Type.AutoScalePolicy) {
            AutoScalePolicyVO policy = ApiDBUtils.findAutoScalePolicyById(job.getInstanceId());
            if (policy != null) {
                jobInstanceId = policy.getUuid();
            }
        } else if (job.getInstanceType() == AsyncJob.Type.AutoScaleVmProfile) {
            AutoScaleVmProfileVO profile = ApiDBUtils.findAutoScaleVmProfileById(job.getInstanceId());
            if (profile != null) {
                jobInstanceId = profile.getUuid();
            }
        } else if (job.getInstanceType() == AsyncJob.Type.AutoScaleVmGroup) {
            AutoScaleVmGroupVO group = ApiDBUtils.findAutoScaleVmGroupById(job.getInstanceId());
            if (group != null) {
                jobInstanceId = group.getUuid();
            }
        } else if (job.getInstanceType() != AsyncJob.Type.None) {
            // TODO : when we hit here, we need to add instanceType -> UUID
            // entity table mapping
            assert (false);
        }
        return jobInstanceId;
    }

    ///////////////////////////////////////////////////////////////////////
    //  Newly Added Utility Methods for List API refactoring             //
    ///////////////////////////////////////////////////////////////////////

    public static DomainRouterResponse newDomainRouterResponse(DomainRouterJoinVO vr, Account caller) {
        return _domainRouterJoinDao.newDomainRouterResponse(vr, caller);
    }

    public static DomainRouterResponse fillRouterDetails(DomainRouterResponse vrData, DomainRouterJoinVO vr){
        return _domainRouterJoinDao.setDomainRouterResponse(vrData, vr);
    }

    public static List<DomainRouterJoinVO> newDomainRouterView(VirtualRouter vr){
        return _domainRouterJoinDao.newDomainRouterView(vr);
    }

    public static UserVmResponse newUserVmResponse(String objectName, UserVmJoinVO userVm, EnumSet<VMDetails> details, Account caller) {
        return _userVmJoinDao.newUserVmResponse(objectName, userVm, details, caller);
    }

    public static UserVmResponse fillVmDetails(UserVmResponse vmData, UserVmJoinVO vm){
        return _userVmJoinDao.setUserVmResponse(vmData, vm);
    }

    public static List<UserVmJoinVO> newUserVmView(UserVm... userVms){
        return _userVmJoinDao.newUserVmView(userVms);
    }

    public static SecurityGroupResponse newSecurityGroupResponse(SecurityGroupJoinVO vsg, Account caller) {
        return _securityGroupJoinDao.newSecurityGroupResponse(vsg, caller);
    }

    public static SecurityGroupResponse fillSecurityGroupDetails(SecurityGroupResponse vsgData, SecurityGroupJoinVO sg){
        return _securityGroupJoinDao.setSecurityGroupResponse(vsgData, sg);
    }

    public static List<SecurityGroupJoinVO> newSecurityGroupView(SecurityGroup sg){
        return _securityGroupJoinDao.newSecurityGroupView(sg);
    }

    public static List<SecurityGroupJoinVO> findSecurityGroupViewById(Long sgId){
        return _securityGroupJoinDao.searchByIds(sgId);
    }

    public static ResourceTagResponse newResourceTagResponse(ResourceTagJoinVO vsg, boolean keyValueOnly) {
        return _tagJoinDao.newResourceTagResponse(vsg, keyValueOnly);
    }

    public static ResourceTagJoinVO newResourceTagView(ResourceTag sg){
        return _tagJoinDao.newResourceTagView(sg);
    }

    public static ResourceTagJoinVO findResourceTagViewById(Long tagId){
        List<ResourceTagJoinVO> tags = _tagJoinDao.searchByIds(tagId);
        if ( tags != null && tags.size() > 0 ){
            return tags.get(0);
        }
        else{
            return null;
        }
    }

    public static EventResponse newEventResponse(EventJoinVO ve) {
        return _eventJoinDao.newEventResponse(ve);
    }

    public static EventJoinVO newEventView(Event e){
        return _eventJoinDao.newEventView(e);
    }

    public static InstanceGroupResponse newInstanceGroupResponse(InstanceGroupJoinVO ve) {
        return _vmGroupJoinDao.newInstanceGroupResponse(ve);
    }

    public static InstanceGroupJoinVO newInstanceGroupView(InstanceGroup e){
        return _vmGroupJoinDao.newInstanceGroupView(e);
    }

    public static UserResponse newUserResponse(UserAccountJoinVO usr) {
        return _userAccountJoinDao.newUserResponse(usr);
    }

    public static UserAccountJoinVO newUserView(User usr){
        return _userAccountJoinDao.newUserView(usr);
    }

    public static UserAccountJoinVO newUserView(UserAccount usr){
        return _userAccountJoinDao.newUserView(usr);
    }

    public static ProjectResponse newProjectResponse(ProjectJoinVO proj) {
        return _projectJoinDao.newProjectResponse(proj);
    }

    public static ProjectResponse fillProjectDetails(ProjectResponse rsp, ProjectJoinVO proj){
        return _projectJoinDao.setProjectResponse(rsp,proj);
    }

    public static List<ProjectJoinVO> newProjectView(Project proj){
        return _projectJoinDao.newProjectView(proj);
    }

    public static List<UserAccountJoinVO> findUserViewByAccountId(Long accountId){
        return _userAccountJoinDao.searchByAccountId(accountId);
    }

    public static ProjectAccountResponse newProjectAccountResponse(ProjectAccountJoinVO proj) {
        return _projectAccountJoinDao.newProjectAccountResponse(proj);
    }

    public static ProjectAccountJoinVO newProjectAccountView(ProjectAccount proj) {
        return _projectAccountJoinDao.newProjectAccountView(proj);
    }

    public static ProjectInvitationResponse newProjectInvitationResponse(ProjectInvitationJoinVO proj) {
        return _projectInvitationJoinDao.newProjectInvitationResponse(proj);
    }

    public static ProjectInvitationJoinVO newProjectInvitationView(ProjectInvitation proj) {
        return _projectInvitationJoinDao.newProjectInvitationView(proj);
    }

    public static HostResponse newHostResponse(HostJoinVO vr, EnumSet<HostDetails> details) {
        return _hostJoinDao.newHostResponse(vr, details);
    }

    public static HostResponse fillHostDetails(HostResponse vrData, HostJoinVO vr){
        return _hostJoinDao.setHostResponse(vrData, vr);
    }

    public static HostForMigrationResponse newHostForMigrationResponse(HostJoinVO vr, EnumSet<HostDetails> details) {
        return _hostJoinDao.newHostForMigrationResponse(vr, details);
    }

    public static HostForMigrationResponse fillHostForMigrationDetails(HostForMigrationResponse vrData, HostJoinVO vr) {
        return _hostJoinDao.setHostForMigrationResponse(vrData, vr);
    }

    public static List<HostJoinVO> newHostView(Host vr){
        return _hostJoinDao.newHostView(vr);
    }

    public static VolumeResponse newVolumeResponse(VolumeJoinVO vr) {
        return _volJoinDao.newVolumeResponse(vr);
    }


    public static VolumeResponse fillVolumeDetails(VolumeResponse vrData, VolumeJoinVO vr){
        return _volJoinDao.setVolumeResponse(vrData, vr);
    }

    public static List<VolumeJoinVO> newVolumeView(Volume vr){
        return _volJoinDao.newVolumeView(vr);
    }

    public static StoragePoolResponse newStoragePoolResponse(StoragePoolJoinVO vr) {
        return _poolJoinDao.newStoragePoolResponse(vr);
    }

    public static StoragePoolResponse fillStoragePoolDetails(StoragePoolResponse vrData, StoragePoolJoinVO vr){
        return _poolJoinDao.setStoragePoolResponse(vrData, vr);
    }

    public static StoragePoolResponse newStoragePoolForMigrationResponse(StoragePoolJoinVO vr) {
        return _poolJoinDao.newStoragePoolForMigrationResponse(vr);
    }

    public static StoragePoolResponse fillStoragePoolForMigrationDetails(StoragePoolResponse
            vrData, StoragePoolJoinVO vr){
        return _poolJoinDao.setStoragePoolForMigrationResponse(vrData, vr);
    }

    public static List<StoragePoolJoinVO> newStoragePoolView(StoragePool vr){
        return _poolJoinDao.newStoragePoolView(vr);
    }


    public static AccountResponse newAccountResponse(AccountJoinVO ve) {
        return _accountJoinDao.newAccountResponse(ve);
    }

    public static AccountJoinVO newAccountView(Account e){
        return _accountJoinDao.newAccountView(e);
    }

    public static AccountJoinVO findAccountViewById(Long accountId) {
        return _accountJoinDao.findByIdIncludingRemoved(accountId);
    }

    public static AsyncJobResponse newAsyncJobResponse(AsyncJobJoinVO ve) {
        return _jobJoinDao.newAsyncJobResponse(ve);
    }

    public static AsyncJobJoinVO newAsyncJobView(AsyncJob e){
        return _jobJoinDao.newAsyncJobView(e);
    }

   public static DiskOfferingResponse newDiskOfferingResponse(DiskOfferingJoinVO offering) {
       return _diskOfferingJoinDao.newDiskOfferingResponse(offering);
   }

   public static DiskOfferingJoinVO newDiskOfferingView(DiskOffering offering){
       return _diskOfferingJoinDao.newDiskOfferingView(offering);
   }

   public static ServiceOfferingResponse newServiceOfferingResponse(ServiceOfferingJoinVO offering) {
       return _serviceOfferingJoinDao.newServiceOfferingResponse(offering);
   }

   public static ServiceOfferingJoinVO newServiceOfferingView(ServiceOffering offering){
       return _serviceOfferingJoinDao.newServiceOfferingView(offering);
   }

   public static ZoneResponse newDataCenterResponse(DataCenterJoinVO dc, Boolean showCapacities) {
       return _dcJoinDao.newDataCenterResponse(dc, showCapacities);
   }

   public static DataCenterJoinVO newDataCenterView(DataCenter dc){
       return _dcJoinDao.newDataCenterView(dc);
   }

   public static Map<String, String> findHostDetailsById(long hostId){
	   return _hostDetailsDao.findDetails(hostId);
   }

   public static List<NicSecondaryIpVO> findNicSecondaryIps(long nicId) {
       return _nicSecondaryIpDao.listByNicId(nicId);
   }

    public static AffinityGroup getAffinityGroup(String groupName, long accountId) {
        return _affinityGroupDao.findByAccountAndName(accountId, groupName);
    }

    public static AffinityGroupResponse newAffinityGroupResponse(AffinityGroupJoinVO group) {
        return _affinityGroupJoinDao.newAffinityGroupResponse(group);
    }

    public static AffinityGroupResponse fillAffinityGroupDetails(AffinityGroupResponse resp, AffinityGroupJoinVO group) {
        return _affinityGroupJoinDao.setAffinityGroupResponse(resp, group);
    }

    public static List<? extends LoadBalancer> listSiteLoadBalancers(long gslbRuleId) {
        return _gslbService.listSiteLoadBalancers(gslbRuleId);
    }

    public static String getDnsNameConfiguredForGslb() {
        String providerDnsName = _configDao.getValue(Config.CloudDnsName.key());
        return providerDnsName;
    }
}