Below is the class that updates sharing of person accounts
Each person account has a Record Owner and can only see their owned records, but once few person accounts are grouped together(households__Household__c) as a relation group and each of the person accounts are its members (households__Householdmember__c) their respective owners all should get sharring rule set to see all those records that come under one group. We have had trouble getting the batch job that runs of this to work, we noticed that when creating new shares we have not accounted for inactive record owners, how do I acheive this ? on the bolded code how do I add a if userid is active then only perform the create new share

public without sharing class SL_HouseholdMember_Handler {

    static Map<Id,RecordType> mapFamily_Household;

    static {
                mapFamily_Household = new Map<Id,RecordType>([
                    SELECT Id, DeveloperName FROM RecordType WHERE SobjectType = 'households__Household__c' AND DeveloperName IN ('Family', 'Household')
                ]);
    }

    public static void updateOwnerOnInsert( Map<ID, households__HouseholdMember__c> hhMembers ) {
        
        Set<Id> set_ParentIds = new Set<Id>();
        for(households__HouseholdMember__c hhm : hhMembers.values()) set_ParentIds.add(hhm.households__Household__c);
        

        Map<Id,Integer> mapHhId2ChildCount = new Map<Id,Integer>();
        Integer tmpInt;
        for(households__HouseholdMember__c hhm : [SELECT Id, households__Household__c FROM households__HouseholdMember__c WHERE households__Household__c IN :set_ParentIds]) {
            if(!mapHhId2ChildCount.containsKey(hhm.households__Household__c)) mapHhId2ChildCount.put(hhm.households__Household__c, 0);
            tmpInt = mapHhId2ChildCount.get(hhm.households__Household__c);
            tmpInt++;
            mapHhId2ChildCount.put(hhm.households__Household__c, tmpInt);
        }
        

        Set<Id> set_ParentId_toNewOwner = new Set<Id>();
        for(households__HouseholdMember__c hhm : hhMembers.values()){
            if(mapHhId2ChildCount.get(hhm.households__Household__c) == 1)
                set_ParentId_toNewOwner.add(hhm.households__Household__c);
        }

        

        if(set_ParentId_toNewOwner.size() > 0) {
            
            String profileName3letter = [SELECT Name FROM Profile WHERE Id = :UserInfo.getProfileId() LIMIT 1].Name.substring(0,3);
            
            Id newOwnerId;
            SL_WM_Config__c cs = SL_WM_Config__c.getOrgDefaults();
            
            
            if(profileName3letter == 'IMC') newOwnerId = cs.IMC_Relationship_Group_Owner__c;
            if(profileName3letter == 'PCA') newOwnerId = cs.PCA_Relationship_Group_Owner__c;
            

            if(newOwnerId != null) {
                List<households__Household__c> lstHH = [SELECT Id, OwnerId FROM households__Household__c WHERE Id IN :set_ParentId_toNewOwner];
                
                for(households__Household__c hh : lstHH) {
                    hh.OwnerId = newOwnerId;
                }
                
                update lstHH;
            }
        }
    }


    public static void householdMember_Share( Map<ID, households__HouseholdMember__c> hhMembers, String mode) {
        
        Map<Id,Set<Id>> mapHhId2setUser = new Map<Id,Set<Id>>();

        Set<Id> set_HhIds = new Set<Id>();
        for(households__HouseholdMember__c hhm : hhMembers.values()) {
            set_HhIds.add(hhm.households__Household__c);
            mapHhId2setUser.put(hhm.households__Household__c, new Set<Id>());
        }

        Map<Id,Set<Id>> mapHhId2setAccountId = new Map<Id,Set<Id>>();
        Set<Id> setAccountId = new Set<Id>();

        if (set_HhIds.size() >0){
            for(households__HouseholdMember__c hhm : [SELECT households__Household__c, households__Account__c FROM households__HouseholdMember__c WHERE households__Household__c IN :set_HhIds]) {
                if(!mapHhId2setAccountId.containsKey(hhm.households__Household__c)) mapHhId2setAccountId.put(hhm.households__Household__c, new Set<Id>());
                mapHhId2setAccountId.get(hhm.households__Household__c).add(hhm.households__Account__c);
                setAccountId.add(hhm.households__Account__c);
            }
        }
        
        Map<Id,Set<Id>> mapAccountId2setUser = new Map<Id,Set<Id>>();
        if (setAccountId.size() > 0){
            for(AccountTeamMember atm : [SELECT AccountId, UserId FROM AccountTeamMember WHERE AccountId IN :setAccountId]) {
                
                Set<Id> userIDSet = new Set<Id>();

                if(mapAccountId2setUser.containsKey(atm.AccountId)) {
                    userIDSet = mapAccountId2setUser.get(atm.AccountId);
                }
                userIDSet.add(atm.UserId);
                mapAccountId2setUser.put(atm.AccountId, userIDSet);
            }
        }

        if (mapAccountId2setUser.size() > 0){
        
            for(Id hhId : mapHhId2setAccountId.keySet()) {
                //mapHhId2setUser.put(hhId, new Set<Id>());
                for(Id accountId : mapHhId2setAccountId.get(hhId)) {
                    //if(!mapHhId2setUser.containsKey(hhId)) mapHhId2setUser.put(hhId, new Set<Id>());
                    if (mapAccountId2setUser.containsKey(accountId)){
                        mapHhId2setUser.get(hhId).addAll(mapAccountId2setUser.get(accountId));
                    }
                }
            }
        }
        updateShares(mapHhId2setUser);
        
    }

    public static void updateSharesForRelationshipGroup(Id relGroupID){

        Map<Id, Set<Id>> houseHoldIDToAccountIdSet = new Map<Id, Set<Id>>();
        Set<Id> householdIDSet = new Set<Id>();

        houseHoldIDToAccountIdSet.put(relGroupID, new Set<ID>());
        householdIDSet.add(relGroupID);

        processHouseHoldMembers(householdIDSet, houseHoldIDToAccountIdSet);
    }

    public static void updateSharesForAccount(List<Account> personAccountList){

        updateSharesForAccount((new Map<Id, Account>(personAccountList)).keySet());

    }

    public static void updateSharesForAccount(Set<Id> personAccountIDset){

        Map<Id, Set<Id>> houseHoldIDToAccountIdSet = new Map<Id, Set<Id>>();
        
        List<Households__HouseholdMember__c> householdMembers = [select Id, Households__Household__c from households__HouseholdMember__c where households__Account__c in :personAccountIDset];
        Set<Id> householdIDSet = new Set<Id>();

        for (Households__HouseholdMember__c member : householdMembers){
            householdIDSet.add(member.Households__Household__c);
            houseHoldIDToAccountIdSet.put(member.Households__Household__c, new Set<Id>());
        }
        
        processHouseHoldMembers(householdIDSet, houseHoldIDToAccountIdSet);

    }

    public static void updateSharesForAccount(Id personAccountID){

        //determine what users are needed per household that this account is part of
        Set<Id> accountIDSet = new Set<Id>();
        accountIDSet.add(personAccountID);
        updateSharesForAccount(accountIDSet);
        
        //get all 
        
       

    }
    public static void processHouseHoldMembers(Set<Id> householdIDSet, Map<Id, Set<Id>> houseHoldIDToAccountIdSet){


        Map<Id, Set<Id>> accountIDToCovgTeamSet = new Map<Id, Set<Id>>();
        //get all household members, for the household
        List<Households__HouseholdMember__c> allHouseholdMembersOfGroups = [select Id, Households__Household__c, Households__Account__c from households__HouseholdMember__c where Households__Household__c in :householdIDSet];

        //get all accounts 
        Set<Id> accountIDSet = new Set<Id>();

        for (Households__HouseholdMember__c member : allHouseholdMembersOfGroups){
            accountIdSet = houseHoldIDToAccountIdSet.get(member.Households__Household__c);
            accountIdSet.add(member.Households__Account__c);
            houseHoldIDToAccountIdSet.put(member.Households__Household__c, accountIdSet);

            accountIDSet.add(member.Households__Account__c);
            accountIDToCovgTeamSet.put(member.Households__Account__c, new Set<Id>());
        }

        //get all coverate teams
        List<AccountTeamMember> covgTeamMembers = [select AccountId, UserId from AccountTeamMember where AccountId in :accountIDSet];

        for (AccountTeamMember teammember : covgTeamMembers){
            Set<Id> covgTeamSet = accountIDToCovgTeamSet.get(teammember.AccountId);
            covgTeamSet.add(teammember.UserId);   
            accountIDToCovgTeamSet.put(teammember.AccountId, covgTeamSet);         
        }

        Map<Id, Set<ID>> householdToUserIdSet = new Map<Id, Set<ID>>();
        //get all household members that this account is a memmebr of, get coverage teams members of household members
        for (Id householdIDKey : houseHoldIDToAccountIdSet.keySet()){
                Set<Id> userIDSet = new Set<Id>();
                if (householdToUserIdSet.containsKey(householdIDKey)){
                    userIDSet = householdToUserIdSet.get(householdIDKey);
                }
               //get accountidset for household
                Set<Id> accountIDForHouseholdSet = houseHoldIDToAccountIdSet.get(householdIDKey);
                //get users
                for (Id accID : accountIDForHouseholdSet){
                    userIDSet.addAll(accountIDToCovgTeamSet.get(accID));
                }
                householdToUserIdSet.put(householdIDKey,userIDSet);
        }
        

        if (householdToUserIdSet.size() > 0){
            updateShares(householdToUserIdSet);
        }

    }

    public static void updateShares(Map<Id,Set<Id>> mapHhId2setUsers_Needed) {
        
        List<households__Household__share> lstShares  = new List<households__Household__share>();
        
        Set<Id> set_UserIds = new Set<Id>();
        for(Id accountId : mapHhId2setUsers_Needed.keySet()) set_UserIds.addAll(mapHhId2setUsers_Needed.get(accountId));
        
        //Id rowCauseID = Schema.households__Household__share.RowCause.AccountCoverageSync__c;
        if (mapHhId2setUsers_Needed.size() > 0 ){
            lstShares = [
                SELECT ParentId, UserOrGroupId  //AccessLevel, RowCause, Id
                FROM households__Household__share 
                WHERE ParentId IN :mapHhId2setUsers_Needed.keySet() 
                    AND RowCause = :Schema.households__Household__share.RowCause.AccountCoverageSync__c
                    //AND UserOrGroupId IN :set_UserIds
            ];
        }
        

        Map<Id,Set<Id>> mapHhId2setUsers_Exist = new Map<Id,Set<Id>>();
        if (lstShares.size() > 0){
            for(households__Household__share hhs : lstShares) {
                if(!mapHhId2setUsers_Exist.containsKey(hhs.ParentId)) mapHhId2setUsers_Exist.put(hhs.ParentId, new Set<Id>());
                mapHhId2setUsers_Exist.get(hhs.ParentId).add(hhs.UserOrGroupId);
            }
        }
        


        // Create NEW shares
        List<households__Household__share> lstShare_toInsert = new List<households__Household__share>();
        Set<Id> curSet_Exist;
        for(Id hhId : mapHhId2setUsers_Needed.keySet()) {
            curSet_Exist = mapHhId2setUsers_Exist.get(hhId);
            //if(curSet_Exist != null) {
                for(Id userId : mapHhId2setUsers_Needed.get(hhId)) {
                    if( curSet_Exist == null || ( curSet_Exist != null && !curSet_Exist.contains(userId) ) ) {
                        // TODO Insert Record
                        households__Household__share newShare = new households__Household__share();
                        newShare.ParentId = hhId;
                        newShare.UserOrGroupId = userId;
                        newShare.AccessLevel = 'Edit';
                        newShare.RowCause =  Schema.households__Household__share.RowCause.AccountCoverageSync__c;
                        lstShare_toInsert.add(newShare);
                    }
                }
            //}
        }
        
        if(lstShare_toInsert.size() > 0) insert lstShare_toInsert;


        // Delete NOT needed shares
        Map<Id,Set<Id>> mapHhId2setUsers_prepDelete = new Map<Id,Set<Id>>();
        Set<Id> set_UserIds_prepDelete = new Set<Id>();
        Set<Id> curSet_Needed;
        for(Id hhId : mapHhId2setUsers_Exist.keySet()) {
            curSet_Needed = mapHhId2setUsers_Needed.get(hhId);
            
            //if(curSet_Needed != null) {
                for(Id userId : mapHhId2setUsers_Exist.get(hhId)) {
                    if(curSet_Needed == null || ( curSet_Needed != null && !curSet_Needed.contains(userId) ) ){
                        if(!mapHhId2setUsers_prepDelete.containsKey(hhId)) mapHhId2setUsers_prepDelete.put(hhId, new Set<Id>());
                        mapHhId2setUsers_prepDelete.get(hhId).add(userId);
                        set_UserIds_prepDelete.add(userId);
                    }
                }
            //}
        }
        
        List<households__Household__share> lstShares_toDelete = new List<households__Household__share>();
        if (set_UserIds_prepDelete.size() > 0){
            for(households__Household__share hhs :[SELECT Id, ParentId, UserOrGroupId //, AccessLevel, RowCause 
                                                    FROM households__Household__share 
                                                    WHERE RowCause = :Schema.households__Household__share.RowCause.AccountCoverageSync__c and ParentId IN :mapHhId2setUsers_prepDelete.keySet() 
                                                        AND UserOrGroupId IN :set_UserIds_prepDelete])
            {
                if( mapHhId2setUsers_prepDelete.containsKey(hhs.ParentId) && mapHhId2setUsers_prepDelete.get(hhs.ParentId).contains(hhs.UserOrGroupId) ) {
                    lstShares_toDelete.add(hhs);
                }
            }
        }
        
        if(lstShares_toDelete.size() > 0) delete lstShares_toDelete;
    }

}