<?php

class PreordercampaignController extends mfBaseController {
  
  protected function init() {
    $this->needlogin=true;
    $me = new User();
    $me->loadMe();
    $this->me = $me;
    $this->layout()->set("me",$me);
    
    if(!$me->is(["Admin", "netowner", "salespartner"])) {
      $this->redirect("Dashboard");
    }
  }
  
  protected function indexAction() {
    $this->layout()->setTemplate("Preordercampaign/Index");
    
    $this->layout->set("filter", $this->request->filter);
    
    $filter = [];
    if($this->request->filter) {
      $filter = $this->getPreparedFilter($this->request->filter);
    }
    
    // pagination defaults
    $pagination = [];
    $pagination['start'] = 0;
    $pagination['count'] = 20;
    $pagination['maxItems'] = 0;
    
    if(is_numeric($this->request->s)) {
      $pagination['start'] = intval($this->request->s);
    }
    
    $my_networks = [];
    //var_dump($filter);exit;
    if($this->me->is("Admin")) {
      if(!is_array($filter['network_id']) && $filter['network_id']) {
        $my_networks[] = new Network($filter['network_id']);
      } else {
        $my_networks = NetworkModel::getAll();
      }
      $this->layout()->set("mynetworks", NetworkModel::getAll());
      
      $netowners = $this->getNetworkOwners($my_network_ids);
      $this->layout()->set("netowners", $netowners);
      
    } else {
      $use_filter_network = false;
      $my_networks = $this->me->myNetworks(["netowner", "salespartner"]);
      
      // check users allowed networks
      $user_network_ids = $this->me->getFlag("preorder_networks")->value();
      if($user_network_ids) {
        $user_network_ids = json_decode($user_network_ids);
      }
      
      if(is_array($user_network_ids) && count($user_network_ids)) {
        
        if(!$my_networks) {
          foreach($user_network_ids as $mnid) {
            $my_networks[] = new Network($mnid);
          }
        } else {
          //var_dump($user_network_ids, $my_networks);exit;
          $new_my_networks = [];
          foreach($my_networks as $network) {
            if(in_array($network->id, $user_network_ids)) {
              $new_my_networks[$network->id] = $network;
            }
          }
          $my_networks = $new_my_networks;
        }
      }
      
      //var_dump($my_networks);exit;
      foreach($my_networks as $mn) {
        if($mn->id == $filter['network_id']) {
          $use_filter_network = true;
          break;
        }
      }
      
      $this->layout()->set("mynetworks", $my_networks);
      
      if($use_filter_network) {
        $my_networks = [];
        $my_networks[] = new Network($filter['network_id']);
      }
      
      $my_network_ids = [];
      foreach($my_networks as $network) {
        $my_network_ids[] = $network->id;
      }
      $filter['network_id'] = $my_network_ids;
    }
    
    
    $pagination['maxItems'] = PreordercampaignModel::count($filter);
    $campaigns = PreordercampaignModel::search($filter, $pagination);
    
    $this->layout()->set("pagination", $pagination);
    $this->layout()->set("campaigns", $campaigns);
    
    
  }
  
  private function getPreparedFilter($filter) {
    $new_filter = [];
    
    if(array_key_exists("netowner", $filter) && $filter['netowner']) {
      if($this->me->is("Admin")) {
        $owner_id = $filter['netowner'];
        foreach(NetworkModel::search(['owner_id' => $owner_id]) as $network) {
          $new_filter['network_id'][] = $network->id;
        }
        unset($filter['network_id']);
      } else {
        unset($filter['netowner']);
      }
    }
    
    if(array_key_exists("name", $filter) && $filter['name']) {
      $new_filter['name%'] = "%".$filter['name'];
      unset($filter['name']);
    }
    if(array_key_exists("area", $filter) && $filter['area']) {
      $new_filter['area%'] = "%".$filter['area'];
      unset($filter['area']);
    }
    
    foreach($filter as $name => $value) {
      $new_filter[$name] = $value;
    }
    
    return $new_filter;
  }
  
  private function getNetworkOwners() {
    $owners = [];
    
    $sql = "SELECT Address.* FROM Preordercampaign
            LEFT JOIN Network ON (Preordercampaign.network_id = Network.id)
            LEFT JOIN Address ON (Network.owner_id = Address.id)
            GROUP BY Address.id
            ORDER BY Address.company, Address.lastname, Address.firstname
    ";
    $res = $this->db()->query($sql);
    if($this->db()->num_rows($reso)) {
      while($data = $this->db()->fetch_object($res)) {
        $owners[] = new Address($data->id);
      }
    }
    
    return $owners;
  }
  
  protected function addAction() {
    if(!$this->me->is("Admin")) {
      $this->redirect("Preordercampaign");
    }
    
    $this->layout()->setTemplate("Preordercampaign/Form");
    
    if($this->me->isAdmin()) {
      $this->layout()->set("networks", NetworkModel::getAll());
    } else {
      $this->layout()->set("networks", $this->me->my_networks);
    }
    
    $this->layout()->set("types", BuildingtypeModel::getAll());
    $this->layout()->set("statuses", BuildingstatusModel::getAll());
    
    $this->layout()->set("networksections", NetworksectionModel::getAll());
    
    $this->layout()->set("adb_netzgebiete", ADBNetzgebietModel::getAll());
    
    
  }
  
  protected function editAction() {
    if(!$this->me->is("Admin")) {
      $this->redirect("Preordercampaign");
    }
    
    $id = $this->request->id;
    if(!is_numeric($id) || !$id) {
      $this->layout()->setFlash("Vorbestellkampagne nicht gefunden", "error");
      $this->redirect("Preordercampaign");
    }
    
    $campaign = new Preordercampaign($id);
    if(!$campaign->id) {
      $this->layout()->setFlash("Vorbestellkampagne nicht gefunden", "error");
      $this->redirect("Preordercampaign");
    }
    
    $this->layout()->set("campaign", $campaign);
    
    return $this->addAction();
  }
  
  protected function saveAction() {
    if(!$this->me->is("Admin")) {
      $this->redirect("Preordercampaign");
    }
    
    $r = $this->request;
    //var_dump($r);exit;
    $id = $r->id;
    if(is_numeric($id) && $id > 0) {
      $mode = "edit";
      $campaign = new Preordercampaign($id);
      if(!$campaign->id) {
        $this->layout()->setFlash("Vorbestellkampagne nicht gefunden", "error");
        $this->redirect("Preordercampaign");
      }
    } else {
      $id = false;
      $mode = "add";
    }
    
    $data = [];
    $data['network_id'] = $r->network_id;
    $data['name'] = $r->name;
    $data['description'] = $r->description;
    $data['area'] = $r->area;
    $data['note'] = $r->note;
    $data['homes_total'] = (int)$r->homes_total;
    
    if($r->from) {
      $data['from'] = self::dateToTimestamp($r->from);
    }
    
    if($r->to) {
      $data['to'] = self::dateToTimestamp($r->to);
    }
    
    if($r->fulfillment == "thirdparty") {
      $data['fulfillment'] = "thirdparty";
    } elseif($r->fulfillment == "rimo") {
      $data['fulfillment'] = "rimo";
    } else {
      $data['fulfillment'] = "thetool";
    }
    
    if($r->oaid_origin == "ofaa") {
      $data['oaid_origin'] = "ofaa";
    } else {
      $data['oaid_origin'] = "thetool";
    }
    
    if($r->product_type == "setup_only") {
      $data['product_type'] = "setup_only";
    } elseif($r->product_type == "no_setup") {
      $data['product_type'] = "no_setup";
    } else {
      $data['product_type'] = "all";
    }
    
    if(is_array($r->required_fields) && count($r->required_fields)) {
      $rfields = [];
      foreach(['contact_type'] as $afield) {
        if(in_array($afield, $r->required_fields)) {
          $rfields[] = "contact_type";
        }
      }
      $data['required_preorder_fields'] = json_encode($rfields);
    } else {
      $data['required_preorder_fields'] = null;
    }
    
    if($r->district_is_city == 1) {
      $data['district_is_city'] = 1;
    } else {
      $data['district_is_city'] = 0;
    }
    
    if($r->hausnummer_add_zusatz == 1) {
      $data['hausnummer_add_zusatz'] = 1;
    } else {
      $data['hausnummer_add_zusatz'] = 0;
    }
    
    if($r->exist_is_error == 1) {
      $data['exist_is_error'] = 1;
    } else {
      $data['exist_is_error'] = 0;
    }
    
    //var_dump($r->banned_rimo_fcp);exit;
    if($r->banned_rimo_fcp && is_array($r->banned_rimo_fcp) && count($r->banned_rimo_fcp)) {
      $banned_fcp_json = json_encode($r->banned_rimo_fcp);
      if($banned_fcp_json) {
        $data["banned_rimo_fcp"] = $banned_fcp_json;
      } else {
        $data["banned_rimo_fcp"] = null;
      }
    } else {
      $data["banned_rimo_fcp"] = null;
    }
    
    $data['edit_by'] = $this->me->id;
    
    if($mode == "add") {
      $data['create_by'] = $this->me->id;
      $campaign = PreordercampaignModel::create($data);
    } else {
      $campaign->update($data);
    }
    
    $new_id = $campaign->save();
    if(!$new_id) {
      $this->layout()->setFlash("Fehler beim Speichern", "error");
      $this->layout()->set("campaign", $campaign);
      return $this->add();
    }
    
    if(is_array($r->types) && count($r->types)) {
      $campaign->addTypes($r->types);
    }
    
    //var_dump($r->adb_netzgebiet_ids);exit;
    foreach(PreordercampaignSalesclusterModel::search(['preordercampaign_id' => $campaign->id]) as $pcg) {
      $pcg->delete();
    }
    //var_dump($r->adb_netzgebiet_ids);exit;
    if(is_array($r->adb_netzgebiet_ids) && count($r->adb_netzgebiet_ids)) {
      foreach($r->adb_netzgebiet_ids as $netzgebiet_id) {
        $pcg = PreordercampaignSalesclusterModel::getFirst(['preordercampaign_id' => $campaign->id, 'salescluster_id' => $netzgebiet_id]);
        if($pcg) continue;
        
        $pcg = PreordercampaignSalesclusterModel::create(['preordercampaign_id' => $campaign->id, 'salescluster_id' => $netzgebiet_id]);
        $pcg->save();
      }
    }
    
    foreach(PreordercampaignApiuserModel::search(['preordercampaign_id' => $campaign->id]) as $pca) {
      $pca->delete();
    }
    if(is_array($r->apiusers) && count($r->apiusers)) {
      foreach($r->apiusers as $user_id) {
        $pca = PreordercampaignApiuserModel::getFirst(['preordercampaign_id' => $campaign->id, 'worker_id' => $user_id]);
        if($pca) continue;
        
        $pca = PreordercampaignApiuserModel::create(['preordercampaign_id' => $campaign->id, 'worker_id' => $user_id]);
        $pca->save();
      }
    }
    
    foreach(PreordercampaignOriginhostnameModel::search(['preordercampaign_id' => $campaign->id]) as $origin) {
      $origin->delete();
    }
    //  var_dump($r->corsorigins);exit;
    if($r->corsorigins) {
      $origins = str_replace("\r", "\n", $r->corsorigins);
      $origins = preg_replace("/\n+/", "\n", $origins);
      $origins = explode("\n", $origins);
      if(is_array($origins) && count($origins)) {
        foreach($origins as $origin) {
          $poh = PreordercampaignOriginhostnameModel::getFirst(['preordercampaign_id' => $campaign->id, 'hostname' => $origin]);
          if($poh) continue;

          $poh = PreordercampaignOriginhostnameModel::create(['preordercampaign_id' => $campaign->id, 'hostname' => $origin]);
          $poh->save();
        }
      }
    }
    
    $this->layout()->setFlash("Vorbestellkampagne erfolgreich gespeichert.", "success");
    //$this->redirect("Preordercampaign", "Edit", ['id' => $new_id]);
    $this->redirect("Preordercampaign");
    
  }
 
  protected function downloadAddonServices() {
    $id = $this->request->preordercampaign_id;
    if(!is_numeric($id) || !$id) {
      $this->layout()->setFlash("Vorbestellkampagne nicht gefunden", "error");
      $this->redirect("Preordercampaign");
    }
    
    $campaign = new Preordercampaign($id);
    if(!$campaign->id) {
      $this->layout()->setFlash("Vorbestellkampagne nicht gefunden", "error");
      $this->redirect("Preordercampaign");
    }
    
    $this->layout()->set("campaign", $campaign);
    $preorders = PreorderModel::search(["preordercampaign_id" => $id, "add-where" => "AND JSON_LENGTH(addon_services) > 1"]);
    
    if(!count($preorders)) {
      $this->layout->setFlash("Keine Vorbestellungen mit bestellten Dienstleistungen gefunden.");
      $this->redirect("Preordercampaign");
    }
    
    $csv = [];
    foreach($preorders as $preorder) {
      $sjson = json_decode($preorder->addon_services);
      if(!$sjson) {
        continue;
      }
      
      // address data and stuff
      $general = [
        "ucode" => $preorder->ucode,
        "gemeinde" => $preorder->adb_hausnummer->ortschaft->gemeinde->name,
        "plz" => $preorder->adb_hausnummer->plz->plzstring,
        "ortschaft" => $preorder->adb_hausnummer->ortschaft->name,
        "strasse" => $preorder->adb_hausnummer->strasse->name,
        "hausnummer" => $preorder->adb_hausnummer->hausnummer,
        "block" => "",
        "stiege" => "",
        "stock" => "",
        "tuer" => "",
        "zusatz" => "",
        "address_info" => $preorder->address_info,
        "contact_firma" => $preorder->company,
        "contact_uid" => $preorder->uid,
        "contact_firstname" => $preorder->firstname,
        "contact_lastname" => $preorder->lastname,
        "contact_street" => $preorder->street,
        "contact_plz" => $preorder->zip,
        "contact_ort" => $preorder->city,
        "phone" => $preorder->phone,
        "email" => $preorder->email,
      ];
      
      if($preorder->adb_wohneinheit_id) {
        $general["block"] = $preorder->adb_wohneinheit->block;
        $general["stiege"] = $preorder->adb_wohneinheit->stiege;
        $general["stock"] = $preorder->adb_wohneinheit->stock;
        $general["tuer"] = $preorder->adb_wohneinheit->tuer;
        $general["zusatz"] = $preorder->adb_wohneinheit->zusatz;
      }
      
      foreach($sjson as $service) {
        if(!$service->ordered) continue;
        
        $s = $general;
        $s["service"] = $service->service;
        $data = [];
        foreach($service->data as $d) {
          $data[] = (string)$d->name.": ".(is_bool($d->value) ? (int)$d->value : (string)$d->value);
        }
        $s["service_data"] = implode("; ", $data);
        $csv[] = $s;
      }
      //var_dump($csv);exit;
      $this->layout()->setTemplate("Preordercampaign/services.csv");
      $this->layout()->set("csv", $csv);
    }
    
  }
  
  protected function adminAction() {
    $this->layout()->setTemplate("Preordercampaign/Admin");
    
    $id = $this->request->id;
    if(!is_numeric($id) || !$id) {
      $this->layout()->setFlash("Vorbestellkampagne nicht gefunden", "error");
      $this->redirect("Preordercampaign");
    }
    
    $campaign = new Preordercampaign($id);
    if(!$campaign->id) {
      $this->layout()->setFlash("Vorbestellkampagne nicht gefunden", "error");
      $this->redirect("Preordercampaign");
    }
    
    $this->layout()->set("campaign", $campaign);
  }
  
  protected function updateUnitOAIDs() {
    $this->layout()->setTemplate("Preordercampaign/Admin");
    
    $id = $this->request->id;
    if(!is_numeric($id) || !$id) {
      $this->layout()->setFlash("Vorbestellkampagne nicht gefunden", "error");
      $this->redirect("Preordercampaign");
    }
    
    $campaign = new Preordercampaign($id);
    if(!$campaign->id) {
      $this->layout()->setFlash("Vorbestellkampagne nicht gefunden", "error");
      $this->redirect("Preordercampaign");
    }
    
    $updated_units = 0;
    
    foreach(PreorderModel::search(["preordercampaign_id" => $id, 'deleted' => 0]) as $preorder) {
      if(!$preorder->adb_wohneinheit_id) continue;
      if(!$preorder->oaid) continue;
      $unit = $preorder->adb_wohneinheit;
      
      if(!$preorder->oaid || $unit->oaid != $preorder->oaid) {
        $preorder->save();
        $updated_units++;
      }
    }
    
    $this->layout()->setFlash("$updated_units Wohneinheiten aktualisiert", "success");
    $this->redirect("Preordercampaign", "Admin", ["id" => $id]);
    
  }
  
  protected function assignOpenAccessIdsToPreorders() {
    $this->layout()->setTemplate("Preordercampaign/Admin");
    
    $id = $this->request->id;
    if(!is_numeric($id) || !$id) {
      $this->layout()->setFlash("Vorbestellkampagne nicht gefunden", "error");
      $this->redirect("Preordercampaign");
    }
    
    $campaign = new Preordercampaign($id);
    if(!$campaign->id) {
      $this->layout()->setFlash("Vorbestellkampagne nicht gefunden", "error");
      $this->redirect("Preordercampaign");
    }
    
    $assigned_oaids = 0;
    $multiple_unit = 0;
    
    foreach(PreorderModel::search(["preordercampaign_id" => $id, "oaid" => null, 'deleted' => 0]) as $preorder) {
      if($preorder->type == "interest") {
        continue;
      }
      
      if($preorder->oaid) {
        $this->log->warning(__METHOD__.": OAID is set already");
        continue;
      }
      
      if(!$preorder->adb_wohneinheit_id) {
        //echo "Keine Wohneinheit in Preorder (".$preorder->id.") ".$preorder->ucode." ".$preorder->oaid."\n";
        continue;
      }
      $wohneinheit = new ADBWohneinheit($preorder->adb_wohneinheit_id);
      if(!$wohneinheit->id) {
        $this->log->error(__METHOD__.": Wohneinheit nicht gefunden (Preorder ".$preorder->id." ".$preorder->ucode." ".$preorder->oaid.")");
        continue;
      }
      
      /*if(!$wohneinheit->extref) {
        continue;
      }*/
      
      $wohneinheit_count = PreorderModel::count(["deleted" => 0, "adb_wohneinheit_id" => $wohneinheit->id]);
      if($wohneinheit_count > 1) {
        $this->log->error(__METHOD__.": Wohneinheit ".$wohneinheit->id." is assigned to multiple preorders!");
        $multiple_unit++;
        continue;
      }
      
      $netowner = new Address($campaign->network->owner_id);
      //var_dump($netowner);exit;
      // get random active OAID from network owner pool
      
      $oaid_attributes = [
        "owner_id" => $netowner->id,
        "origin" => $campaign->oaid_origin
      ];
      
      if($this->request->origin_id) {
        $oaid_attributes["origin_id"] = $this->request->origin_id;
      }
      
      $preorder->setOrCreateOaid($oaid_attributes);
      
      if($wohneinheit->oaid != $oaid->oaid) {
        $wohneinheit->oaid = $oaid->oaid;
        $wohneinheit->save();
      }
      
      $assigned_oaids++;
      
    }
    
    $this->layout()->setFlash("$assigned_oaids OAIDs wurden Vorbestellungen zugewiesen", "success");
    $this->redirect("Preordercampaign", "Admin", ["id" => $id]);
  }
  
  protected function createRimoWorkordersAction() {
    $this->layout()->setTemplate("Preordercampaign/Admin");
    
    $id = $this->request->id;
    if(!is_numeric($id) || !$id) {
      $this->layout()->setFlash("Vorbestellkampagne nicht gefunden", "error");
      $this->redirect("Preordercampaign");
    }
    
    $campaign = new Preordercampaign($id);
    if(!$campaign->id) {
      $this->layout()->setFlash("Vorbestellkampagne nicht gefunden", "error");
      $this->redirect("Preordercampaign");
    }
    
    $missing_units = [];
    $missing_extrefs = [];
    $workorders_created = 0;
    $workorders_failed = 0;
    
    foreach(PreorderModel::search(["preordercampaign_id" => $id, "rimo_workorder" => false, 'deleted' => 0]) as $preorder) {
      if($preorder->workorder_export_date) {
        $this->log->warning(__METHOD__.": workorder_export_date not null");
      }
      
      if($preorder->type == "interest") {
        continue;
      }
      
      if(!$preorder->adb_wohneinheit_id) {
        //echo "Keine Wohneinheit in Preorder (".$preorder->id.") ".$preorder->ucode." ".$preorder->oaid."\n";
        $missing_units[] = $preorder;
        continue;
      }
      $wohneinheit = new ADBWohneinheit($preorder->adb_wohneinheit_id);
      if(!$wohneinheit->id) {
        $this->log->error(__METHOD__.": Wohneinheit nicht gefunden (Preorder ".$preorder->id." ".$preorder->ucode." ".$preorder->oaid.")");
        continue;
      }
      
      if(!$wohneinheit->extref) {
        $missing_extrefs[] = $preorder;
        continue;
      }
      
      if(!$preorder->oaid) {
        $preorder->setOrCreateOaid();
        if(!$preorder->oaid) {
          continue;
        }
      }
      
      $oaid = OpenAccessIdModel::getFirstOaid($wohneinheit->oaid);
      if(!$oaid) {
        $this->log->warning(__METHOD__.": OAID '".$wohneinheit->oaid."' not found");
        continue;
      }
      // create and assign OAID if not yet done
      $oaid->exportToRimoAndAssignFtu();
      
      // create Workorder
      $params['apiKey'] = RIMO_API_JSON_APIKEY;
      $params["homeId"] = $wohneinheit->extref;
      $params["firstName"] = trim($preorder->firstname);
      $params["lastName"] = trim($preorder->lastname);
      $params["company"] = trim($preorder->company);
      $params["phone"] = trim($preorder->phone);
      $params["email"] = trim($preorder->email);
      $params["orderId"] = $preorder->ucode;
      //$params["openAccessId"] = $preorder->oaid; // TODO: flag in campaign to include OAID or not
      
      $ctx_opts = [
        'http' => [
          'method' => 'POST',
          'header' => 'accept: application/json'
        ]
      ];
      
      $qs = http_build_query($params);
      //echo $qs."\n";
      
      $createOrderEp = RIMO_API_JSON_URL.RIMO_API_JSON_EP_CREATE_WORKORDER;
      $post_url = $createOrderEp."?".$qs;
      $ctx = stream_context_create($ctx_opts);
      $this->log->debug(__METHOD__.": Creating Workorder: $post_url");
      
      $response = file_get_contents($post_url, false, $ctx);
      
      if($response === false) {
        echo "Fehler beim Exportieren der Workorder für Preorder ".$preorder->id." ".$preorder->ucode." ".$preorder->oaid."\n";
        $workorders_failed++;
        continue;
      }
      //$preorder->workorder_export_date = date('U');
      //$preorder->workorder_export_data = $response;
      //$preorder->save();
      $resp_data = json_decode($response);
      if(!is_object($resp_data)) {
        $this->log->error("Cannot create RimoWorkorder! Invalid Response! (Preorder code: ".$preorder->ucode.") | Response: \n$response");
        throw new Exception("Cannot create RimoWorkorder! Invalid Response! (Preorder code: ".$preorder->ucode.")");
      }
      
      $wo = RimoWorkorderModel::create([
        "rimo_id" => $resp_data->id,
        "rimo_name" => $resp_data->name,
        "adb_wohneinheit_id" => $preorder->adb_wohneinheit_id,
        "create_data" => $response
      ]);
      $wo->save();
      $workorders_created++;
    }
    
    $errors = [];
    $warnings = [];
    
    if(count($missing_units)) {
      $warnings[] = count($missing_units)." Vobestellungen ohne Wohneinheit";
    }
    if(count($missing_extrefs)) {
      $warnings[] = count($missing_extrefs)." Wohneinheiten ohne extref (SDIHome_)";
    }
    
    
    if($workorders_failed) {
      $errors[] = "$workorders_failed Workorders konnten nicht erstellt werden.";
    }
    
    
    if(count($errors)) {
      $this->layout()->setFlash(implode("<br />\n", $errors), "error");
    }
    if(count($warnings)) {
      $this->layout()->setFlash(implode("<br />\n", $warnings), "warning");
    }
    
    if($workorders_created) {
      $this->layout()->setFlash("$workorders_created Workorders erfolgreich erstellt", "success");
    } else {
      $this->layout()->setFlash("Es konnten keine Workorders erstellt werden", "info");
    }
    
    $this->redirect("Preordercampaign", "Admin", ["id" => $id]);
    
  }
  
  protected function exportOaidsToRimo() {
    
    $this->layout()->setTemplate("Preordercampaign/Admin");
    
    $id = $this->request->id;
    if(!is_numeric($id) || !$id) {
      $this->layout()->setFlash("Vorbestellkampagne nicht gefunden", "error");
      $this->redirect("Preordercampaign");
    }
    
    $campaign = new Preordercampaign($id);
    if(!$campaign->id) {
      $this->layout()->setFlash("Vorbestellkampagne nicht gefunden", "error");
      $this->redirect("Preordercampaign");
    }
    
    $oaid_assigned = 0;
    $missing_units = 0;
    $missing_extrefs = 0;
    $missing_oaid = 0;
    
    foreach(PreorderModel::search(["preordercampaign_id" => $id, 'deleted' => 0]) as $preorder) {
      if($preorder->type == "interest") {
        $this->log->debug(__METHOD__.": Ignoring Preorder ".$preorder->id.": is interest");
        continue;
      }
      
      if(!$preorder->adb_wohneinheit_id) {
        //echo "Keine Wohneinheit in Preorder (".$preorder->id.") ".$preorder->ucode." ".$preorder->oaid."\n";
        $this->log->debug(__METHOD__.": Ignoring Preorder ".$preorder->id.": missing unit");
        $missing_units++;
        continue;
      }
      $wohneinheit = new ADBWohneinheit($preorder->adb_wohneinheit_id);
      if(!$wohneinheit->id) {
        $this->log->error(__METHOD__.": Wohneinheit nicht gefunden (Preorder ".$preorder->id." ".$preorder->ucode." ".$preorder->oaid.")");
        continue;
      }
      
      if(!$wohneinheit->extref) {
        $missing_extrefs++;
        continue;
      }
      
      if(!$preorder->oaid) {
        $missing_oaid++;
        continue;
      }
      
      // TODO; OpenaccessID::exportToRimoFtu
      $oaid = OpenAccessIdModel::getFirstOaid($wohneinheit->oaid);
      if(!$oaid) {
        $this->log->warning("Cannot export OAID to rimo because not found: ".$wohneinheit->oaid." (Preorder ".$preorder->id." ".$preorder->ucode." ".$preorder->oaid.")");
        continue;
      }
      
      if($oaid->exportToRimoAndAssignFtu()) {
        $oaid_assigned++;
      }
    }
    
    $this->layout()->setFlash("$oaid_assigned OAIDs erfolgreich erstellt und/oder FTUs zugeordnet.<br />$missing_units missing units<br />$missing_extrefs missing extref<br />$missing_oaid missing oaid");
    $this->redirect("Preordercampaign", "Admin", ["id" => $id]);
    
  }
}