PHP CIdSante400::store方法代码示例

 /**
  * Handle event A47
  *
  * @param CHL7Acknowledgment $ack     Acknowledgment
  * @param CPatient           $patient Person
  * @param array              $data    Data
  *
  * @return string
  */
 function handleA47(CHL7Acknowledgment $ack, CPatient $patient, $data)
 {
     $exchange_hl7v2 = $this->_ref_exchange_hl7v2;
     $sender = $exchange_hl7v2->_ref_sender;
     $sender->loadConfigValues();
     $this->_ref_sender = $sender;
     $incorrect_identifier = null;
     // Traitement du mode simple, cad
     if (CHL7v2Message::$handle_mode == "simple") {
         $MRG_4 = $this->queryNodes("MRG.4", $data["MRG"])->item(0);
         $incorrect_identifier = $this->queryTextNode("CX.1", $MRG_4);
         $patient->load($incorrect_identifier);
         // ID non connu (non fourni ou non retrouvé)
         if (!$incorrect_identifier || !$patient->_id) {
             return $exchange_hl7v2->setAckAR($ack, "E141", null, $patient);
         }
     } else {
         $MRG_1 = $this->queryNodes("MRG.1", $data["MRG"])->item(0);
         if ($this->queryTextNode("CX.5", $MRG_1) == "PI") {
             $incorrect_identifier = $this->queryTextNode("CX.1", $MRG_1);
         }
         // Chargement de l'IPP
         $IPP_incorrect = new CIdSante400();
         if ($incorrect_identifier) {
             $IPP_incorrect = CIdSante400::getMatch("CPatient", $sender->_tag_patient, $incorrect_identifier);
         }
         // PI non connu (non fourni ou non retrouvé)
         if (!$incorrect_identifier || !$IPP_incorrect->_id) {
             return $exchange_hl7v2->setAckAR($ack, "E141", null, $patient);
         }
         $patient->load($IPP_incorrect->object_id);
         // Passage en trash de l'IPP du patient a éliminer
         if ($msg = $patient->trashIPP($IPP_incorrect)) {
             return $exchange_hl7v2->setAckAR($ack, "E140", $msg, $patient);
         }
     }
     // Sauvegarde du nouvel IPP
     $IPP = new CIdSante400();
     $IPP->object_id = $patient->_id;
     $IPP->object_class = "CPatient";
     $IPP->id400 = $data['personIdentifiers']["PI"];
     $IPP->tag = $sender->_tag_patient;
     $IPP->last_update = CMbDT::dateTime();
     if ($msg = $IPP->store()) {
         return $exchange_hl7v2->setAckAR($ack, "E140", $msg, $patient);
     }
     return $exchange_hl7v2->setAckAA($ack, "I140", null, $patient);
 }

 /**
  * Search and map a user inside the LDAP
  *
  * @param CUser       $user
  * @param CSourceLDAP $source_ldap
  * @param resource    $ldapconn
  * @param string      $person       [optional]
  * @param string      $filter       [optional]
  * @param boolean     $force_create [optional]
  *
  * @return CUser
  */
 static function searchAndMap(CUser $user, CSourceLDAP $source_ldap, $ldapconn, $person = null, $filter = null, $force_create = false)
 {
     if (!$person) {
         $person = $user->user_username;
     }
     $person = utf8_encode($person);
     if (!$filter) {
         $filter = "(samaccountname={$person})";
     }
     $results = $source_ldap->ldap_search($ldapconn, $filter);
     if (!$results || $results["count"] == 0) {
         $user->_bound = false;
         $user->_count_ldap = 0;
         return $user;
     }
     if ($results["count"] > 1) {
         throw new CMbException("CSourceLDAP_too-many-results");
     }
     $results = $results[0];
     $idex = new CIdSante400();
     $idex->tag = CAppUI::conf("admin LDAP ldap_tag");
     $idex->object_class = "CUser";
     $idex->id400 = self::getObjectGUID($results);
     $idex->loadMatchingObject();
     // On sauvegarde le password renseigné
     $user_password = $user->user_password;
     $_user_password = $user->_user_password;
     // objectguid retrouvé on charge le user
     if ($idex->_id) {
         $user = new CUser();
         $user->load($idex->object_id);
     } else {
         // objectguid non retrouvé on associe à l'user courant l'objectguid
         // Si on est pas en mode création on le recherche
         if (!$force_create) {
             // Suppression du password pour le loadMatchingObject
             $user->user_password = null;
             $user->_user_password = null;
             $user->loadMatchingObject();
             if (!$user->_id) {
                 throw new CMbException("Auth-failed-user-unknown");
             }
         }
     }
     $user->_bound = true;
     $user = self::mapTo($user, $results);
     // Save Mediuser variables
     $actif = $user->_user_actif;
     $deb_activite = $user->_user_deb_activite;
     $fin_activite = $user->_user_fin_activite;
     // Restore User password variables
     $user->user_password = $user_password;
     $user->_user_password = $_user_password;
     if (!$user->user_type) {
         $user->user_type = 0;
     }
     // Pas de profil
     $user->template = 0;
     $user->user_login_errors = 0;
     $user->repair();
     $msg = $user->store();
     if ($msg) {
         throw new CMbException($msg);
     }
     if (!$force_create && !$user->_ref_mediuser->actif || $force_create && !$actif) {
         throw new CMbException("Auth-failed-user-deactivated");
     }
     // Restore Mediuser variables
     $user->_user_actif = $actif;
     $user->_user_deb_activite = $deb_activite;
     $user->_user_fin_activite = $fin_activite;
     $user->_count_ldap = 1;
     if (!$idex->_id) {
         $idex->object_id = $user->_id;
         $idex->last_update = CMbDT::dateTime();
         if ($msg = $idex->store()) {
             throw new CMbException($msg);
         }
     }
     return $user;
 }

 /**
  * Store Acte
  *
  * @param String[] $data    Value
  * @param String   $type    CCAM or NGAP
  * @param CSejour  $sejour  Sejour
  * @param CPatient $patient Patient
  * @param String   $tag     Tag
  *
  * @return String|CActe;
  */
 function storeActe($data, $type, $sejour, $patient, $tag)
 {
     $code_acte = "code";
     if ($type == "CCAM") {
         $field_object = "codes_ccam";
         $code_acte = "code_acte";
     }
     $action = $data["action"];
     $idex = CIdSante400::getMatch("CActe{$type}", $tag, $data["idSourceActe{$type}"]);
     $executant_id = $data["executant_id"];
     if ($idex->_id) {
         $class = "CActe{$type}";
         /** @var CActeCCAM|CActeNGAP $acte */
         $acte = new $class();
         $acte->load($idex->object_id);
         $object = $acte->loadTargetObject();
         if ($action === "suppression") {
             if ($type == "CCAM") {
                 $code = $acte->{$code_acte};
                 $replace = explode("|", $object->{$field_object});
                 CMbArray::removeValue($code, $replace);
                 $object->{$field_object} = $replace ? implode("|", $replace) : "";
             }
             if ($msg = $this->deleteActe($acte, $object, $idex)) {
                 return $msg;
             }
             return $acte;
         }
         /** @var CActeCCAM|CActeNGAP $new_acte */
         $new_acte = $this->{"createActe{$type}"}($data["acte{$type}"], $object, $executant_id);
         $modification = $new_acte->{$code_acte} != $acte->{$code_acte};
         if ($modification) {
             if ($type == "CCAM") {
                 $new_code = preg_replace("#{$acte}->{$code_acte}#", $new_acte->{$code_acte}, $object->{$field_object}, 1);
                 $object->{$field_object} = $new_code;
             }
             if ($msg = $this->deleteActe($acte, $object, $idex)) {
                 return $msg;
             }
             $acte = new $class();
         }
         $acte->extendsWith($new_acte, true);
         if ($msg = $acte->store()) {
             return $msg;
         }
         if ($modification) {
             $idex->setObject($acte);
             if ($msg = $idex->store()) {
                 return $msg;
             }
         }
         return $acte;
     }
     if ($action !== "création") {
         return "{$action} impossible car l'acte n'a pas été trouvé";
     }
     $date = CMbDT::date($data["acte{$type}"]["date"]);
     $object = $this->getObject($date, $executant_id, $patient->_id);
     $object = $object ? $object : $sejour;
     /** @var CActe $acte */
     $acte = $this->{"createActe{$type}"}($data["acte{$type}"], $object, $executant_id);
     if ($type == "CCAM") {
         $object->{$field_object} .= $object->{$field_object} ? "|{$acte->{$code_acte}}" : $acte->{$code_acte};
     }
     if ($msg = $object->store()) {
         return $msg;
     }
     if ($msg = $acte->store()) {
         return $msg;
     }
     $idex = new CIdSante400();
     $idex->id400 = $data["idSourceActe{$type}"];
     $idex->tag = $tag;
     $idex->setObject($acte);
     if ($msg = $idex->store()) {
         return $msg;
     }
     return $acte;
 }

 /**
  * Recording RI sender
  *
  * @param string         $RI_sender Idex value
  * @param CPatient       $patient   Patient
  * @param CInteropSender $sender    Sender
  *
  * @return null|string null if successful otherwise returns and error message
  */
 static function storeRISender($RI_sender, CPatient $patient, CInteropSender $sender)
 {
     $domain = $sender->loadRefDomain();
     $idex = new CIdSante400();
     $idex->object_class = "CPatient";
     $idex->object_id = $patient->_id;
     $idex->tag = $domain->tag;
     $idex->id400 = $RI_sender;
     return $idex->store();
 }

 /**
  * Merge an array of objects
  *
  * @param self[] $objects An array of CMbObject to merge
  * @param bool   $fast    Tell wether to use SQL (fast) or PHP (slow but checked and logged) algorithm
  *
  * @return string|null
  */
 function merge($objects, $fast = false)
 {
     $alternative_mode = $this->_id != null;
     // Modes and object count check
     if ($alternative_mode && count($objects) > 1) {
         return "mergeAlternativeTooManyObjects";
     }
     if (!$alternative_mode && count($objects) < 2) {
         return "mergeTooFewObjects";
     }
     // Trigger before event
     $this->notify("BeforeMerge");
     if (!$this->_id && ($msg = $this->store())) {
         $this->notify("MergeFailure");
         return $msg;
     }
     foreach ($objects as $object) {
         $this->_merging[$object->_id] = $object;
     }
     foreach ($objects as &$object) {
         $msg = $fast ? $this->fastTransferBackRefsFrom($object) : $this->transferBackRefsFrom($object);
         if ($msg) {
             $this->notify("MergeFailure");
             return $msg;
         }
         $object_id = $object->_id;
         $object->_mergeDeletion = true;
         if ($msg = $object->delete()) {
             return $msg;
         }
         // If external IDs are available, we save old objects' id as external IDs
         if (CModule::getInstalled("dPsante400")) {
             $idex = new CIdSante400();
             $idex->setObject($this);
             $idex->tag = "merged";
             $idex->id400 = $object_id;
             $idex->last_update = CMbDT::dateTime();
             $idex->store();
         }
     }
     // Trigger after event
     $this->notify("AfterMerge");
     return $this->store();
 }

 /**
  * Trigger when merge failed
  *
  * @param CMbObject $mbObject Object
  *
  * @return bool
  */
 function onMergeFailure(CMbObject $mbObject)
 {
     if (!$this->isHandled($mbObject)) {
         return false;
     }
     // On va réatribuer les idexs en cas de problème dans la fusion
     foreach ($mbObject->_fusion as $group_id => $infos_fus) {
         if (!$infos_fus || !array_key_exists("idexs_changed", $infos_fus)) {
             return false;
         }
         foreach ($infos_fus["idexs_changed"] as $idex_id => $tag_name) {
             $idex = new CIdSante400();
             $idex->load($idex_id);
             if (!$idex->_id) {
                 continue;
             }
             // Réattribution sur l'objet non supprimé
             $sejour_elimine = $infos_fus["sejourElimine"];
             $idex->object_id = $sejour_elimine->_id;
             $idex->tag = $tag_name;
             $idex->last_update = CMbDT::dateTime();
             $idex->store();
         }
     }
 }

 * @license  GNU General Public License, see http://www.gnu.org/licenses/gpl.html 
 * @version  SVN: $Id:$ 
 * @link     http://www.mediboard.org
 */
CApp::setTimeLimit(240);
CApp::setMemoryLimit("512M");
CCanDo::checkAdmin();
$d1_id = CValue::request("domain_1_id");
$d2_id = CValue::request("domain_2_id");
$idex_ids = CValue::request("idex_ids", array());
/* Traitement prélable pour passer en "trash" les idexs en erreurs */
foreach ($idex_ids as $_idex => $idex_id) {
    $idex = new CIdSante400();
    $idex->load($idex_id);
    $idex->tag = "trash_{$idex->tag}";
    $idex->store();
}
/* checkMerge */
$domains_id = array($d1_id, $d2_id);
$domains = array();
$checkMerge = array();
if (count($domains_id) != 2) {
    $checkMerge[] = CAppUI::tr("mergeTooFewObjects");
}
foreach ($domains_id as $domain_id) {
    $domain = new CDomain();
    // the CMbObject is loaded
    if (!$domain->load($domain_id)) {
        CAppUI::setMsg("Chargement impossible de l'objet [{$domain_id}]", UI_MSG_ERROR);
        continue;
    }

if ($verouillee) {
    $tagCatalogue = CAppUI::conf('dPlabo CCatalogueLabo remote_name');
    $prescription_labo_id = CValue::post("prescription_labo_id");
    $prescription = new CPrescriptionLabo();
    $prescription->load($prescription_labo_id);
    if (!$prescription->verouillee) {
        $prescription->loadRefsFwd();
        // Chargement de l'id400 "labo code4" du praticien
        $prat =& $prescription->_ref_praticien;
        $tagCode4 = "labo code4";
        $idSantePratCode4 = new CIdSante400();
        $idSantePratCode4->loadLatestFor($prat, $tagCode4);
        // creation de l'id400 de la prescription
        $idPresc = new CIdSante400();
        //Paramétrage de l'id 400
        $idPresc->tag = "{$tagCatalogue} Prat:" . str_pad($idSantePratCode4->id400, 4, '0', STR_PAD_LEFT);
        // tag LABO Prat: 0017
        $idPresc->object_class = "CPrescriptionLabo";
        // Chargement du dernier id externe de prescription du praticien s'il existe
        $idPresc->loadMatchingObject("id400 DESC");
        // Incrementation de l'id400
        $idPresc->id400++;
        $idPresc->id400 = str_pad($idPresc->id400, 4, '0', STR_PAD_LEFT);
        $idPresc->_id = null;
        $idPresc->last_update = CMbDT::dateTime();
        $idPresc->object_id = $prescription->_id;
        $idPresc->store();
    }
}
$do = new CDoObjectAddEdit("CPrescriptionLabo");
$do->doIt();

 /**
  * Recording idex
  * 
  * @param CIdSante400    $idex   Object id400
  * @param CMbObject      $object Object
  * @param CInteropSender $sender Sender
  * 
  * @return null|string null if successful otherwise returns and error message
  */
 static function storeIdex(CIdSante400 $idex, CMbObject $object, CInteropSender $sender)
 {
     $idex->object_id = $object->_id;
     $idex->last_update = CMbDT::dateTime();
     return $idex->store();
 }

 /**
  * store the idex
  *
  * @param CPatient|CSejour $object     patient or sejour
  * @param String[]         $identifier identifiers
  * @param String           $tag        tag
  *
  * @return null|String
  */
 function storeIdex($object, $identifier, $tag)
 {
     $idex = new CIdSante400();
     $idex->tag = "{$tag}";
     $idex->id400 = "{$identifier}";
     $idex->setObject($object);
     $idex->loadMatchingObject();
     if ($msg = $idex->store()) {
         return $msg;
     }
     return null;
 }

 /**
  * @see parent::store()
  */
 function store()
 {
     $this->completeField("type");
     if ($this->type == "alle") {
         $this->loadRefDossierMedical();
         $dossier_medical = $this->_ref_dossier_medical;
         if ($dossier_medical->object_class == "CPatient") {
             DSHM::remKeys("alertes-*-CPatient-" . $dossier_medical->object_id);
         }
     }
     // Save owner and creation date
     if (!$this->_id) {
         if (!$this->creation_date) {
             $this->creation_date = CMbDT::dateTime();
         }
         if (!$this->owner_id) {
             $this->owner_id = CMediusers::get()->_id;
         }
     }
     // Standard store
     if ($msg = parent::store()) {
         return $msg;
     }
     // DossierMedical store
     $this->checkCodeCim10();
     // Sauvegarde de l'identifiant externe (code composant de la BDM pour le cas des allergies)
     if ($this->_idex_code && $this->_idex_tag) {
         $idex = new CIdSante400();
         $idex->setObject($this);
         $idex->id400 = $this->_idex_code;
         $idex->tag = $this->_idex_tag;
         $idex->store();
     }
     return null;
 }

 /**
  * Mapping et enregistrement de la venue
  *
  * @param CSejour     &$newVenue          Séjour
  * @param array       $data               Datas
  * @param string      $etatVenueEliminee  État de la venue à éliminer
  * @param CIdSante400 &$idexVenue         Idex de la venue
  * @param CIdSante400 &$idexVenueEliminee Idex de la venue à éliminer
  *
  * @return array
  */
 private function mapAndStoreVenue(&$newVenue, $data, $etatVenueEliminee, CIdSante400 &$idexVenue, CIdSante400 &$idexVenueEliminee)
 {
     $sender = new CDestinataireHprim();
     $sender->nom = $data['idClient'];
     $sender->loadMatchingObject();
     $messages = array();
     // Mapping de la venue a éliminer
     $newVenue = $this->mappingVenue($data['venueEliminee'], $newVenue);
     // Mapping de la venue a garder
     $newVenue = $this->mappingVenue($data['venue'], $newVenue);
     // Notifier les autres destinataires
     $newVenue->_eai_sender_guid = $sender->_guid;
     // Séjour retrouvé
     if ($newVenue->loadMatchingSejour() || $newVenue->_id) {
         $messages['_code_NumDos'] = "A121";
         $messages['_code_Venue'] = "store";
     } else {
         $messages['_code_NumDos'] = "I122";
         $messages['_code_Venue'] = "create";
     }
     $messages['msgVenue'] = $newVenue->store();
     $messages['commentaire'] = CEAISejour::getComment($newVenue);
     $idexVenue->object_id = $newVenue->_id;
     $idexVenue->last_update = CMbDT::dateTime();
     $messages['msgNumDosVenue'] = $idexVenue->store();
     $idexVenueEliminee->tag = $etatVenueEliminee != "préadmission" ? CAppUI::conf('dPplanningOp CSejour tag_dossier_cancel') . $sender->_tag_sejour : CAppUI::conf('dPplanningOp CSejour tag_dossier_pa') . $sender->_tag_sejour;
     $idexVenueEliminee->object_id = $newVenue->_id;
     $idexVenueEliminee->last_update = CMbDT::dateTime();
     $messages['msgNumDosVenueEliminee'] = $idexVenueEliminee->store();
     return $messages;
 }

 /**
  * Handle receive order message
  *
  * @param CHL7v2ReceiveOrderMessageResponse $ack     Acknowledgment
  * @param CPatient                          $patient Person
  * @param array                             $data    Data
  *
  * @return string|void
  */
 function handle(CHL7v2ReceiveOrderMessageResponse $ack, CPatient $patient, $data)
 {
     $exchange_hl7v2 = $this->_ref_exchange_hl7v2;
     $sender = $exchange_hl7v2->_ref_sender;
     $sender->loadConfigValues();
     $this->_ref_sender = $sender;
     $patientPI = CValue::read($data['personIdentifiers'], "PI");
     if (!$patientPI) {
         return $exchange_hl7v2->setORRError($ack, "E007");
     }
     $IPP = CIdSante400::getMatch("CPatient", $sender->_tag_patient, $patientPI);
     // Patient non retrouvé par son IPP
     if (!$IPP->_id) {
         return $exchange_hl7v2->setORRError($ack, "E105");
     }
     $patient->load($IPP->object_id);
     $venueAN = $this->getVenueAN($sender, $data);
     $NDA = CIdSante400::getMatch("CSejour", $sender->_tag_sejour, $venueAN);
     // Séjour non retrouvé par son NDA
     if (!$NDA->_id) {
         return $exchange_hl7v2->setORRError($ack, "E205");
     }
     $sejour = new CSejour();
     $sejour->load($NDA->object_id);
     // Common order - ORC
     $orc = $data["ORC"];
     $obr = $data["OBR"];
     $event_request = $this->getEventRequest($orc);
     $consultation = new CConsultation();
     $placer_id = $this->getPlacerNumber($orc);
     $filler_id = $this->getFillerNumber($orc);
     switch ($event_request) {
         // new order
         case "SN":
             $datetime = $this->getDate($orc);
             $orc12 = $this->getDoctorNode($orc, $data);
             $mediuser = new CMediusers();
             $medisuer_id = $this->getDoctor($orc12, $mediuser);
             if (!$medisuer_id) {
                 return $exchange_hl7v2->setORRError($ack, "E801");
             }
             $consultation->createByDatetime($datetime, $medisuer_id, $patient->_id);
             if (!$consultation->_id) {
                 return $exchange_hl7v2->setORRError($ack, "E802");
             }
             $idex = new CIdSante400();
             $idex->id400 = $filler_id;
             $idex->tag = $sender->_tag_consultation;
             $idex->setObject($consultation);
             $idex->store();
             break;
             //Modification
         //Modification
         case "SC":
             $consultation->load($placer_id);
             $status_code = $this->getStatusCode($orc);
             switch ($status_code) {
                 case "CM":
                     $status = CConsultation::TERMINE;
                     break;
                 case "OD":
                     $status = CConsultation::PLANIFIE;
                     break;
                 case "IP":
                     $status = CConsultation::EN_COURS;
                     break;
                 default:
                     return $exchange_hl7v2->setORRError($ack, "E803");
             }
             $consultation->chrono = $status;
             if ($msg = $consultation->store()) {
                 return $exchange_hl7v2->setORRError($ack, "E804", $msg);
             }
             $obr4 = $this->getExamen("OBR.4", $obr, $data);
             //Identifiant de l'élément de prescription
             $examen_id = $this->getExamenID($obr4);
             $examen_name = $this->getExamenName($obr4);
             //todo gérer avec l'élément de prescription
             break;
             // cancel order request
         // cancel order request
         case "OC":
             $consultation->annule = "1";
             if ($msg = $consultation->store()) {
                 return $exchange_hl7v2->setORRError($ack, "E804", $msg);
             }
             $idex = CIdSante400::getMatchFor($consultation, $sender->_tag_consultation);
             $idex->id400 = "trash_{$idex->id400}";
             if ($msg = $idex->store()) {
                 return $exchange_hl7v2->setORRError($ack, "E805", $msg);
             }
//.........这里部分代码省略.........

        $mediuser->insGroupPermission();
        $results[$i]["result"] = 0;
        $results[$i]["username"] = $mediuser->_user_username;
        $results[$i]["password"] = $mediuser->_user_password;
        $number_idex = $results[$i]["idex"];
        if (!$number_idex) {
            continue;
        }
        $idex = new CIdSante400();
        $idex->tag = CMediusers::getTagMediusers($group_id);
        $idex->id400 = $number_idex;
        if ($idex->loadMatchingObject()) {
            $unfound["idex"][$number_idex] = true;
            CAppUI::setMsg("Identifiant déjà existant", UI_MSG_WARNING);
            continue;
        }
        $idex->setObject($mediuser);
        $msg = $idex->store();
        if ($msg) {
            CAppUI::setMsg($msg, UI_MSG_ERROR);
        }
    }
    fclose($fp);
}
CAppUI::callbackAjax('$("systemMsg").insert', CAppUI::getMsg());
// Création du template
$smarty = new CSmartyDP();
$smarty->assign("dryrun", $dryrun);
$smarty->assign("results", $results);
$smarty->assign("unfound", $unfound);
$smarty->display("user_import_csv.tpl");

 function getIdExterne()
 {
     $idExterne = new CIdSante400();
     // Chargement de l'id externe de la prescription (tag: Imeds)
     $idExterne->loadLatestFor($this, "iMeds");
     if (!$idExterne->_id) {
         // Afactoriser : assez complexe (concatenation du code 4 praticien et du code 4 prescription)
         $tagCatalogue = CAppUI::conf('dPlabo CCatalogueLabo remote_name');
         $this->loadRefsFwd();
         $prat =& $this->_ref_praticien;
         $tagCode4 = "labo code4";
         $idSantePratCode4 = new CIdSante400();
         $idSantePratCode4->loadLatestFor($prat, $tagCode4);
         $idPresc = new CIdSante400();
         $idPresc->tag = "{$tagCatalogue} Prat:" . str_pad($idSantePratCode4->id400, 4, '0', STR_PAD_LEFT);
         // tag LABO Prat: 0017
         $idPresc->object_class = "CPrescriptionLabo";
         $idPresc->loadMatchingObject("id400 DESC");
         $numprovisoire = str_pad($idSantePratCode4->id400, 4, '0', STR_PAD_LEFT) . str_pad($idPresc->id400, 4, '0', STR_PAD_LEFT);
         // Envoi à la source créée 'get_id_prescriptionlabo' (SOAP)
         $exchange_source = CExchangeSource::get("get_id_prescriptionlabo", "soap");
         $exchange_source->setData(array("NumMedi" => $numprovisoire, "pwd" => $exchange_source->password));
         $exchange_source->send("NDOSLAB");
         $idExterne->tag = "iMeds";
         $idExterne->object_class = "CPrescriptionLabo";
         $idExterne->object_id = $this->_id;
         $idExterne->id400 = $exchange_source->getACQ()->NDOSLABResult;
         $idExterne->last_update = CMbDT::dateTime();
         $idExterne->store();
     }
     return $idExterne;
 }