   (let [not-blank? (complement str/blank?)]
     (cond-> []
       (not-blank? Telefonnummer1)
-      (conj {:label Telefonbezeichner1
+      (conj {:label (or Telefonbezeichner1 "")
              :nummer (build-number Vorwahl1 Telefonnummer1)})
       
       (not-blank? Telefonnummer2)
-      (conj {:label Telefonbezeichner2
+      (conj {:label (or Telefonbezeichner2 "")
              :nummer (build-number Vorwahl2 Telefonnummer2)})
       
       (not-blank? Telefonnummer3)
-      (conj {:label Telefonbezeichner3
+      (conj {:label (or Telefonbezeichner3 "")
              :nummer (build-number Vorwahl3 Telefonnummer3)}))))
 
 (defn parse-out-tel [person]

(defn get-adress [{:keys [Straße Zusatz Postleitzahl Ort]}]
  (when-not (every? str/blank? [Straße Zusatz Postleitzahl Ort])
    {:label ""
     :strasse Straße
     :zusatz Zusatz
     :plz Postleitzahl
     :stadt Ort}))

(defn build-number [vorwahl nummer]
  (str vorwahl nummer))

      (update :nicht_abdrucken #(Boolean/parseBoolean %))
      (update :stand #(get stand-map % nil))))


;;;; SQL-Map generation functions

(defn amttypen-sql [_persons]
  (-> (insert-into :public.adressverzeichnis_amttyp)
      (values [{:name "Mitglied"}])))

(defn ordensmitgliedschaften-sql [persons]
  (-> (insert-into :public.adressverzeichnis_amt)
      (values
       (for [{:keys [Ordensgruppe alte_id]} persons
             :when Ordensgruppe]
         {:bestaetigt false
          :gruppierung_id 
          (-> (select :id) (from :public.adressverzeichnis_gruppierung) (where [:= :name Ordensgruppe]))
          :person_id
          (-> (select :id) (from :public.adressverzeichnis_person) (where [:= :alte_id alte_id]))
          :typ_id
          (-> (select :id) (from :public.adressverzeichnis_amttyp) (where [:= :name "Mitglied"]))}))))

(defn addresses-sql [persons]
  (-> (insert-into :public.adressverzeichnis_adresse)
      (values (for [{:keys [address alte_id]} persons]
                (assoc address
                       :person_id
                       (-> (select :id)
                           (from :public.adressverzeichnis_person)
                           (where [:= :alte_id alte_id])))))))

(defn phones-sql [persons]
  (-> (insert-into :public.adressverzeichnis_telefon)
      (values
       (apply concat
        (for [{:keys [numbers alte_id]} persons]
          (for [phone numbers]
            (assoc phone
                   :person_id
                   (-> (select :id)
                       (from :public.adressverzeichnis_person)
                       (where [:= :alte_id alte_id])))))))))

(defn persons-sql [persons]
  (-> (insert-into :public.adressverzeichnis_person)
      (values 
       (map #(merge 
              {:anmerkung ""
               :anrede ""
               :titel ""
               :vorname ""
               :fahrtenname ""
               :nachname ""}
              (select-keys % #{:stand :anmerkung :email :nicht_abdrucken :geburtstag :titel :fahrtenname :nachname :alte_id :todestag :vorname :nrw :anrede}))
          persons))))

(def organe #{"Bundesrat" "Bundesmädchenrat" "Bundesjungenrat" "Bundesthing"})

(defn organs-sql []
  (-> (insert-into :public.adressverzeichnis_organ)
      (values (for [organ organe]
                {:name organ}))))

(defn permission-sql [permissions alte_id]
  (for [[organ permission] permissions
        :when (some true? (map second permission))]
    (assoc permission
           :organ_id (-> (select :id) (from :public.adressverzeichnis_organ) (where [:= :name organ]))
           :person_id (-> (select :id) (from :public.adressverzeichnis_person) (where [:= :alte_id alte_id])))))

(defn pemissions-sql [persons]
  [(organs-sql)
   (-> (insert-into :public.adressverzeichnis_manuelleberechtigung)
       (values
        (apply concat 
          (for [{:keys [permissions alte_id]} persons]
            (permission-sql permissions alte_id)))))])

(defn ordensgruppe-typ [ordensgruppe]
  (and ordensgruppe
