self.serialize

in www/roster/models/ppmc.rb [3:185]
144 lines of code
28 McCabe index (conditional complexity)

  def self.serialize(id, env)

    ppmc = ASF::Podling.find(id)
    return unless ppmc 

    committers = ppmc.members
    owners = ppmc.owners

    
    unknownSubs = []
    asfMembers = []
    
    nonASFmails = {}

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

    
    
    
    
    
    
    

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

    isOwner = false 
    unless analysePrivateSubs
      isOwner = owners.include? currentUser
    end


    
    if analysePrivateSubs or isOwner
      pSubs = ASF::MLIST.private_subscribers(ppmc.mail_list)[0]||[]
      subscribers, subtime = ASF::MLIST.list_subs(ppmc.mail_list, true) 
      if analysePrivateSubs
        unMatchedSubs=Set.new(pSubs) if analysePrivateSubs 
        moderators.each { |_, mods| mods.each {|m| nonASFmails[m]='' unless m.end_with? '@apache.org'} }
      end
      pSubs.map!(&:downcase) 
      lists = ASF::MLIST.domain_lists(ppmc.mail_list, true)
    else
      lists = ASF::MLIST.domain_lists(ppmc.mail_list, false)
    end

    pmc = ASF::Committee.find('incubator')
    ipmc = pmc.owners
    incubator_committers = pmc.committers

    
    roster = committers.map {|person|
      [person.id, {
        
        name: person.public_name,
        member: person.asf_member?,
        icommit: incubator_committers.include?(person),
        role: 'Committer',
        githubUsername: (person.attrs['githubUsername'] || []).join(', ')
      }]
    }.to_h

    
    owners.each do |person|
      roster[person.id] = {
        name: person.public_name,
        member: person.asf_member?,
        icommit: incubator_committers.include?(person),
        role: 'PPMC Member',
        githubUsername: (person.attrs['githubUsername'] || []).join(', ')
      }
      if analysePrivateSubs or isOwner
        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)}
      end
    end

    
    ppmc.mentors.each do |mentor|
      person = ASF::Person.find(mentor)
      roster[person.id] = {
        name: person.public_name,
        member: person.asf_member?,
        ipmc: ipmc.include?(person),
        icommit: incubator_committers.include?(person),
        role: 'Mentor',
        githubUsername: (person.attrs['githubUsername'] || []).join(', ')
      }
      if analysePrivateSubs or isOwner
        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 or isOwner
        unMatchedSubs.delete_if {|k| allMail.include? ASF::Mail.to_canonical(k.downcase)}
      end
    end

    statusInfo = ppmc.podlingStatus || {news: []}

    if unMatchedSubs.length > 0 or nonASFmails.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,v|
        @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
      }
    end

    
    unless isOwner or analysePrivateSubs
      moderators = modtime = nil
    end

    ret = {
      id: id,
      display_name: ppmc.display_name,
      description: ppmc.description,
      mail_list: ppmc.mail_list, 
      schedule: ppmc.reporting,
      monthly: ppmc.monthly,
      established: ppmc.startdate.to_s,
      enddate: ppmc.enddate.to_s,
      status: ppmc.status,
      mentors: ppmc.mentors,
      hasLDAP: ppmc.hasLDAP?,
      owners: owners.map(&:id),
      committers: committers.map(&:id),
      roster: roster,
      mail: lists.sort.to_h,
      moderators: moderators,
      modtime: modtime,
      subscribers: subscribers,
      subtime: subtime,
      nonASFmails: nonASFmails,
      duration: ppmc.duration,
      podlingStatus: statusInfo,
      namesearch: ppmc.namesearch,
      analysePrivateSubs: analysePrivateSubs,
      unknownSubs: unknownSubs,
      asfMembers: asfMembers,
    }
    
    ret[:isOwner] = isOwner if isOwner
    return ret

  end