self.serialize

in www/roster/models/committee.rb [3:215]
170 lines of code
37 McCabe index (conditional complexity)

  def self.serialize(id, env)

    pmc = ASF::Committee.find(id)
    return unless pmc.pmc? 
    owners = pmc.owners
    committers = pmc.committers
    
    ASF::Committee.load_committee_info
    
    ASF::Person.preload(['cn', 'mail', 'asf-altEmail', 'githubUsername'], (owners + committers).uniq)

    comdev = ASF::SVN['comdev-foundation']
    info = JSON.parse(File.read(File.join(comdev, 'projects.json')))[id]

    image = ASF::SiteImage.find(id)

    
    
    
    moderators, modtime = ASF::MLIST.list_moderators(pmc.mail_list)
    subscribers = nil 
    subtime = nil
    pSubs = [] 
    unMatchedSubs = [] 
    unMatchedSecSubs = [] 
    currentUser = ASF::Person.find(env.user)

    
    
    
    
    
    
    


    analysePrivateSubs = currentUser.asf_member?
    unless analysePrivateSubs 
      
      user_mail = currentUser.all_mail || []
      pMods = moderators[pmc.private_mail_list] || []
      analysePrivateSubs = !(pMods & user_mail).empty?
    end

    isPMCMember = false 
    unless analysePrivateSubs
      isPMCMember = pmc.roster.include? env.user
    end

    
    if analysePrivateSubs or isPMCMember
      subscribers, subtime = ASF::MLIST.list_subs(pmc.mail_list) 
      pSubs = ASF::MLIST.private_subscribers(pmc.mail_list)[0]||[]
      unMatchedSubs=Set.new(pSubs) if analysePrivateSubs 
      pSubs.map!(&:downcase) 
      if analysePrivateSubs
        sSubs = ASF::MLIST.security_subscribers(pmc.mail_list)[0]||[]
        unMatchedSecSubs=Set.new(sSubs) 
      end
      lists = ASF::MLIST.domain_lists(pmc.mail_list, true)
    else
      lists = ASF::MLIST.domain_lists(pmc.mail_list, false)
    end

    roster = ASF.dup(pmc.roster) 
    
    roster.each do |key, value|
      value[:role] = 'PMC member'
      next if pmc.ownerids.include?(key) 
      person = ASF::Person[key]
      next unless person  
      if analysePrivateSubs or isPMCMember
        
        allMail = person.all_mail.map{|m| ASF::Mail.to_canonical(m.downcase)}
        
        
        roster[key]['notSubbed'] = true if (allMail & pSubs.map{|m| ASF::Mail.to_canonical(m)}).empty?
      end
      if analysePrivateSubs
        unMatchedSubs.delete_if {|k| allMail.include? ASF::Mail.to_canonical(k.downcase)}
        unMatchedSecSubs.delete_if {|k| allMail.include? ASF::Mail.to_canonical(k.downcase)}
      end
      roster[key]['githubUsername'] = (person.attrs['githubUsername'] || []).join(', ')
    end

    owners.each do |person| 
      roster[person.id] ||= {
        name: person.public_name,
        role: 'PMC member' 
      }
      if analysePrivateSubs or isPMCMember
        
        allMail = person.all_mail.map{|m| ASF::Mail.to_canonical(m.downcase)}
        
        
        roster[person.id]['notSubbed'] = true if (allMail & pSubs.map{|m| ASF::Mail.to_canonical(m)}).empty?
      end
      if analysePrivateSubs
        unMatchedSubs.delete_if {|k| allMail.include? ASF::Mail.to_canonical(k.downcase)}
        unMatchedSecSubs.delete_if {|k| allMail.include? ASF::Mail.to_canonical(k.downcase)}
      end
      roster[person.id]['ldap'] = true
      roster[person.id]['githubUsername'] = (person.attrs['githubUsername'] || []).join(', ')
    end

    committers.each do |person|
      roster[person.id] ||= {
        name: person.public_name,
        role: 'Committer'
      }
      roster[person.id]['githubUsername'] = (person.attrs['githubUsername'] || []).join(', ')
    end

    roster.each {|k, v| v[:member] = ASF::Person.find(k).asf_member?}

    if pmc.chair and roster[pmc.chair.id]
      roster[pmc.chair.id]['role'] = 'PMC chair'
    end

    
    unknownSubs = [] 
    asfMembers = []
    unknownSecSubs = [] 
    
    nonASFmails = {}
    moderators&.each { |_, mods| mods.each {|m| nonASFmails[m] = '' unless m.end_with? '@apache.org'} }
    if unMatchedSubs.length > 0 or nonASFmails.length > 0 or unMatchedSecSubs.length > 0
      load_emails 
      unMatchedSubs.each { |addr|
        who = nil
        @people.each do |person|
          if person[:mail].any? {|mail| mail.downcase == addr.downcase}
            who = person
          end
        end
        if who
          if who[:member]
            asfMembers << { addr: addr, person: who }
          else
            unknownSubs << { addr: addr, person: who }
          end
        else
          unknownSubs << { addr: addr, person: nil }
        end
      }
      nonASFmails.each {|k, _|
        @people.each do |person|
          if person[:mail].any? {|mail| ASF::Mail.to_canonical(mail.downcase) == ASF::Mail.to_canonical(k.downcase)}
            nonASFmails[k] = person[:id]
          end
        end
      }
      unMatchedSecSubs.each { |addr|
        who = nil
        @people.each do |person|
          if person[:mail].any? {|mail| mail.downcase == addr.downcase}
            who = person
          end
        end
        if who
          unless who[:member]
            unknownSecSubs << { addr: addr, person: who }
          end
        else
          unknownSecSubs << { addr: addr, person: nil }
        end
      }
    end

    pmc_chair = false
    if pmc.chair
      pmcchairs = ASF::Service.find('pmc-chairs')
      pmc_chair = pmcchairs.members.include? pmc.chair
    end
    
    unless analysePrivateSubs
      moderators = modtime = subscribers = subtime = nil
      nonASFmails = {}
    end
    ret = {
      id: id,
      chair: pmc.chair&.id,
      chairname: pmc.chair.public_name,
      pmc_chair: pmc_chair,
      display_name: pmc.display_name,
      description: pmc.description,
      schedule: pmc.schedule,
      report: pmc.report,
      site: pmc.site,
      established: pmc.established,
      ldap: owners.map(&:id), 
      members: pmc.roster.keys, 
      committers: committers.map(&:id),
      roster: roster,
      mail: lists.sort.to_h,
      moderators: moderators,
      modtime: modtime,
      subscribers: subscribers,
      subtime: subtime,
      nonASFmails: nonASFmails,
      project_info: info,
      image: image,
      analysePrivateSubs: analysePrivateSubs,
      unknownSubs: unknownSubs,
      asfMembers: asfMembers,
      unknownSecSubs: unknownSecSubs,
    }
    
    ret[:isPMCMember] = isPMCMember if isPMCMember
    return ret

  end