PHP Documento::save方法代码示例

 public function crear()
 {
     $req = $this->request;
     $vdt = $this->validarDocumento($req->post(), true);
     $autor = $this->session->getUser();
     $documento = new Documento();
     $documento->descripcion = $vdt->getData('descripcion');
     $documento->ultima_version = 1;
     $documento->save();
     $docVersion = new VersionDocumento();
     $docVersion->version = 1;
     $docVersion->documento()->associate($documento);
     $docVersion->save();
     $parrafos = $this->parsearParrafos($vdt->getData('cuerpo'));
     foreach ($parrafos as $i => $parrafo) {
         $docParrafo = new ParrafoDocumento();
         $docParrafo->cuerpo = $parrafo;
         $docParrafo->ubicacion = $i;
         $docParrafo->version()->associate($docVersion);
         $docParrafo->save();
     }
     $contenido = new Contenido();
     $contenido->titulo = $vdt->getData('titulo');
     $contenido->puntos = 0;
     $contenido->categoria_id = $vdt->getData('categoria');
     $contenido->autor()->associate($autor);
     $contenido->contenible()->associate($documento);
     $contenido->save();
     TagCtrl::updateTags($contenido, TagCtrl::getTagIds($vdt->getData('tags')));
     UserlogCtrl::createLog('newDocumen', $autor->id, $documento);
     $autor->increment('puntos', 25);
     $this->flash('success', 'Su documento abierto se creó exitosamente.');
     $this->redirectTo('shwDocumen', array('idDoc' => $documento->id));
 }

 public function submit_create_documento()
 {
     if (Auth::check()) {
         $data["inside_url"] = Config::get('app.inside_url');
         $data["user"] = Session::get('user');
         // Verifico si el usuario es un Webmaster
         if ($data["user"]->idrol == 1 || $data["user"]->idrol == 2 || $data["user"]->idrol == 3 || $data["user"]->idrol == 4) {
             // Validate the info, create rules for the inputs
             $attributes = array('nombre' => 'Nombre del Documento', 'descripcion' => 'Descripción', 'autor' => 'Autor', 'codigo_archivamiento' => 'Código de Archivamiento', 'ubicacion' => 'Ubicación', 'archivo' => 'Archivo');
             $messages = array();
             $rules = array('nombre' => 'required|max:100|unique:documentos|alpha_num_spaces', 'descripcion' => 'required|max:200|alpha_num_spaces', 'autor' => 'required|max:100|alpha_num_spaces', 'codigo_archivamiento' => 'required|max:100|unique:documentos|alpha_num', 'ubicacion' => 'required|max:100|alpha_num_spaces', 'archivo' => 'max:15360');
             // Run the validation rules on the inputs from the form
             $validator = Validator::make(Input::all(), $rules, $messages, $attributes);
             // If the validator fails, redirect back to the form
             if ($validator->fails()) {
                 return Redirect::to('documento/create_documento')->withErrors($validator)->withInput(Input::all());
             } else {
                 $data["tipo_documentos"] = TipoDocumentos::searchTipoDocumentosById(Input::get('idtipo_documento'))->get();
                 $rutaDestino = '';
                 $nombreArchivo = '';
                 if (Input::hasFile('archivo')) {
                     $archivo = Input::file('archivo');
                     $rutaDestino = 'uploads/documentos/bienes/' . $data["tipo_documentos"][0]->nombre . '/';
                     $nombreArchivo = $archivo->getClientOriginalName();
                     $nombreArchivoEncriptado = Str::random(27) . '.' . pathinfo($nombreArchivo, PATHINFO_EXTENSION);
                     $uploadSuccess = $archivo->move($rutaDestino, $nombreArchivoEncriptado);
                     $documento = new Documento();
                     $documento->nombre = Input::get('nombre');
                     $documento->nombre_archivo = $nombreArchivo;
                     $documento->nombre_archivo_encriptado = $nombreArchivoEncriptado;
                     $documento->descripcion = Input::get('descripcion');
                     $documento->autor = Input::get('autor');
                     $documento->codigo_archivamiento = Input::get('codigo_archivamiento');
                     $documento->ubicacion = Input::get('ubicacion');
                     $documento->url = $rutaDestino;
                     $documento->idtipo_documento = Input::get('idtipo_documento');
                     $documento->idestado = 1;
                     $documento->save();
                 } else {
                     $documento = new Documento();
                     $documento->nombre = Input::get('nombre');
                     $documento->descripcion = Input::get('descripcion');
                     $documento->autor = Input::get('autor');
                     $documento->codigo_archivamiento = Input::get('codigo_archivamiento');
                     $documento->ubicacion = Input::get('ubicacion');
                     $documento->idtipo_documento = Input::get('idtipo_documento');
                     $documento->idestado = 1;
                     $documento->save();
                 }
                 Session::flash('message', 'Se registró correctamente el Documento.');
                 return Redirect::to('documento/list_documentos');
             }
         } else {
             return View::make('error/error', $data);
         }
     } else {
         return View::make('error/error', $data);
     }
 }

 /**
  * Creates a new model.
  * If creation is successful, the browser will be redirected to the 'view' page.
  */
 public function actionCreate()
 {
     $model = new Documento();
     // Uncomment the following line if AJAX validation is needed
     // $this->performAjaxValidation($model);
     if (isset($_POST['Documento'])) {
         $model->attributes = $_POST['Documento'];
         if ($model->save()) {
             $this->redirect(array('view', 'id' => $model->id));
         }
     }
     $this->render('create', array('model' => $model));
 }

 /**
  * Performs the work of inserting or updating the row in the database.
  *
  * If the object is new, it inserts it; otherwise an update is performed.
  * All related objects are also updated in this method.
  *
  * @param      PropelPDO $con
  * @return     int The number of rows affected by this insert/update and any referring fk objects' save() operations.
  * @throws     PropelException
  * @see        save()
  */
 protected function doSave(PropelPDO $con)
 {
     $affectedRows = 0;
     // initialize var to track total num of affected rows
     if (!$this->alreadyInSave) {
         $this->alreadyInSave = true;
         // We call the save method on the following object(s) if they
         // were passed to this object by their coresponding set
         // method.  This object relates to these object(s) by a
         // foreign key reference.
         if ($this->aEmpresa !== null) {
             if ($this->aEmpresa->isModified() || $this->aEmpresa->isNew()) {
                 $affectedRows += $this->aEmpresa->save($con);
             }
             $this->setEmpresa($this->aEmpresa);
         }
         if ($this->aDocumento !== null) {
             if ($this->aDocumento->isModified() || $this->aDocumento->isNew()) {
                 $affectedRows += $this->aDocumento->save($con);
             }
             $this->setDocumento($this->aDocumento);
         }
         if ($this->aUsuario !== null) {
             if ($this->aUsuario->isModified() || $this->aUsuario->isNew()) {
                 $affectedRows += $this->aUsuario->save($con);
             }
             $this->setUsuario($this->aUsuario);
         }
         // If this object has been modified, then save it to the database.
         if ($this->isModified()) {
             if ($this->isNew()) {
                 $pk = HistoricoDocumentoPeer::doInsert($this, $con);
                 $affectedRows += 1;
                 // we are assuming that there is only 1 row per doInsert() which
                 // should always be true here (even though technically
                 // BasePeer::doInsert() can insert multiple rows).
                 $this->setNew(false);
             } else {
                 $affectedRows += HistoricoDocumentoPeer::doUpdate($this, $con);
             }
             $this->resetModified();
             // [HL] After being saved an object is no longer 'modified'
         }
         $this->alreadyInSave = false;
     }
     return $affectedRows;
 }

 public function creardoc()
 {
     View::content('creardoc');
     if (Input::hasPost('Documento')) {
         $descripcion = $_POST['Documento']['DESCRIPCION'];
         $nombre = $_POST['Documento']['NOMBREDOCUMENTO'];
         $folio = $_POST['Documento']['FOLIO'];
         $fechapublicacion = $_POST['Documento']['FECHAPUBLICACION_AT'];
         $palabrasclave = $_POST['Documento']['PALABRASCLAVE'];
         //$archivo = $_FILES["CONTENIDO"]["tmp_name"];
         $tamanio = $_FILES["CONTENIDO"]["size"];
         $Documento = new Documento(Input::post('Documento'));
         $Documento->initialize();
         if (!$Documento->save()) {
             Flash::error('Falló Operación');
         } else {
         }
     }
 }

 public function actionCrear()
 {
     if (isset($_FILES['file']['name'])) {
         $file_name = $_FILES["file"]["name"];
         $base_path = realpath(Yii::app()->getBasePath() . '/../files');
         $path = $base_path . "/" . $file_name;
         if (!is_dir($base_path)) {
             mkdir($base_path, 0777);
         }
         if ($file_name && move_uploaded_file($_FILES["file"]["tmp_name"], $path)) {
             $documentoModel = new Documento();
             $documentoModel->nombre = $_POST['name'];
             $documentoModel->link = Yii::app()->getBaseUrl() . "/files/" . $file_name;
             $documentoModel->fecha = $_POST['fecha'];
             if ($documentoModel->save()) {
                 $this->sendResponse($documentoModel);
             } else {
                 $this->sendResponse("No se pudo guardar el modelo", 500);
             }
         } else {
             $this->sendResponse("No se pudo guardar el archivo", 500);
         }
     }
 }

 public function submit_create_reporte_padrinos()
 {
     if (Auth::check()) {
         $data["inside_url"] = Config::get('app.inside_url');
         $data["user"] = Session::get('user');
         $data["permisos"] = Session::get('permisos');
         if (in_array('side_nuevo_reporte_padrinos', $data["permisos"])) {
             $anho = date("Y");
             $padrinos = Padrino::getPadrinosActivos($anho)->get();
             if ($padrinos->isEmpty()) {
                 Session::flash('error', 'No se encontraron padrinos asociados al año actual, no se envió ningun correo.');
                 return Redirect::to('padrinos/create_reporte_padrinos');
             }
             if (Input::hasFile('archivo')) {
                 $archivo = Input::file('archivo');
                 $rutaDestino = 'files/reportes_padrinos/';
                 $nombreArchivo = $archivo->getClientOriginalName();
                 $nombreArchivoEncriptado = Str::random(27) . '.' . pathinfo($nombreArchivo, PATHINFO_EXTENSION);
                 $peso = $archivo->getSize();
                 $uploadSuccess = $archivo->move($rutaDestino, $nombreArchivoEncriptado);
                 /* Creo el documento */
                 $documento = new Documento();
                 $documento->titulo = $nombreArchivo;
                 $documento->idtipo_documentos = 2;
                 // ¡Que viva el hardcode!
                 $documento->nombre_archivo = $nombreArchivoEncriptado;
                 $documento->peso = $peso;
                 $documento->ruta = $rutaDestino;
                 $documento->save();
                 $emails = array();
                 foreach ($padrinos as $padrino) {
                     /* Creo la relación del documento con el padrino */
                     $documentos_padrino = new DocumentosPadrino();
                     $documentos_padrino->idpadrinos = $padrino->idpadrinos;
                     $documentos_padrino->iddocumentos = $documento->iddocumentos;
                     $documentos_padrino->save();
                     $emails[] = $padrino->email;
                 }
                 /* Envio las notificaciones via e-mail a los padrinos */
                 Mail::send('emails.reportePadrinos', array('archivo' => $archivo), function ($message) use($emails) {
                     $message->to($emails)->subject('Te queremos informar la labor de AFI PERÚ.');
                 });
                 //Enviar las push notifications a los padrinos y madrinas
                 $padrinos_push = Padrino::getActivePadrinosPushInfo()->get();
                 foreach ($padrinos_push as $padrino_push) {
                     if ($padrino_push->push_reports && $padrino_push->uuid) {
                         $message = 'Te queremos informar la labor de AFI PERÚ.';
                         Helpers::pushAPNS($padrino_push->uuid, $message, 4);
                     }
                 }
                 //Enviar las push notifications (android) a los padrinos y madrinas
                 $gcm_tokens = Padrino::getPadrinosToNotificateReport($anho)->get()->lists('gcm_token');
                 $message = 'Te queremos informar la labor de AFI PERÚ.';
                 $type = 4;
                 $m = ['title' => $title, 'message' => $message, 'type' => $type];
                 Helpers::pushGCM($gcm_tokens, $m);
                 // Llamo a la función para registrar el log de auditoria
                 $descripcion_log = "Se envió el reporte con id {{$documento->iddocumentos}}";
                 Helpers::registrarLog(7, $descripcion_log);
                 Session::flash('message', 'Se envió el reporte correctamente por correo a los padrinos.');
                 return Redirect::to('padrinos/create_reporte_padrinos');
             }
         } else {
             // Llamo a la función para registrar el log de auditoria
             $descripcion_log = "Se intentó acceder a la ruta '" . Request::path() . "' por el método '" . Request::method() . "'";
             Helpers::registrarLog(10, $descripcion_log);
             Session::flash('error', 'Usted no tiene permisos para realizar dicha acción.');
             return Redirect::to('/dashboard');
         }
     } else {
         return View::make('error/error');
     }
 }

 public function submit_upload_file_proyecto()
 {
     if (Auth::check()) {
         $data["inside_url"] = Config::get('app.inside_url');
         $data["user"] = Session::get('user');
         $data["permisos"] = Session::get('permisos');
         if (in_array('side_nuevo_proyecto', $data["permisos"])) {
             // Validate the info, create rules for the inputs
             $rules = array('archivo' => 'required|max:15360|mimes:pdf,doc,docx,xls,xlsx,ppt,pptx');
             // Run the validation rules on the inputs from the form
             $validator = Validator::make(Input::all(), $rules);
             // If the validator fails, redirect back to the form
             $idproyectos = Input::get('idproyectos');
             if ($validator->fails()) {
                 return Redirect::to('concursos/upload_file_proyecto/' . $idproyectos)->withErrors($validator)->withInput(Input::all());
             } else {
                 if (Input::hasFile('archivo')) {
                     $archivo = Input::file('archivo');
                     $rutaDestino = 'files/proyectos/';
                     $nombreArchivo = $archivo->getClientOriginalName();
                     $nombreArchivoEncriptado = Str::random(27) . '.' . pathinfo($nombreArchivo, PATHINFO_EXTENSION);
                     $peso = $archivo->getSize();
                     $uploadSuccess = $archivo->move($rutaDestino, $nombreArchivoEncriptado);
                     /* Creo el documento */
                     $documento = new Documento();
                     $documento->titulo = $nombreArchivo;
                     $documento->idtipo_documentos = 5;
                     $documento->nombre_archivo = $nombreArchivoEncriptado;
                     $documento->peso = $peso;
                     $documento->ruta = $rutaDestino;
                     $documento->save();
                     /* Creo la relación de concurso con documento */
                     $documentos_proyecto = new DocumentosProyecto();
                     $documentos_proyecto->idproyectos = $idproyectos;
                     $documentos_proyecto->iddocumentos = $documento->iddocumentos;
                     $documentos_proyecto->save();
                 }
                 // Llamo a la función para registrar el log de auditoria
                 $descripcion_log = "Se subió el archivo con id {{$documento->iddocumentos}} para el proyecto con id {{$documentos_proyecto->idproyectos}}";
                 Helpers::registrarLog(7, $descripcion_log);
                 Session::flash('message', 'Se subió correctamente el archivo.');
                 return Redirect::to('concursos/upload_file_proyecto/' . $idproyectos);
             }
         } else {
             // Llamo a la función para registrar el log de auditoria
             $descripcion_log = "Se intentó acceder a la ruta '" . Request::path() . "' por el método '" . Request::method() . "'";
             Helpers::registrarLog(10, $descripcion_log);
             Session::flash('error', 'Usted no tiene permisos para realizar dicha acción.');
             return Redirect::to('/dashboard');
         }
     } else {
         return View::make('error/error');
     }
 }

 public function editar_form($documento_id = NULL)
 {
     $documento = NULL;
     if ($documento_id) {
         $documento = Doctrine::getTable('Documento')->find($documento_id);
     } else {
         $documento = new Documento();
         $documento->proceso_id = $this->input->post('proceso_id');
     }
     if ($documento->Proceso->cuenta_id != UsuarioBackendSesion::usuario()->cuenta_id) {
         echo 'Usuario no tiene permisos para editar este documento.';
         exit;
     }
     $this->form_validation->set_rules('nombre', 'Nombre', 'required');
     $this->form_validation->set_rules('tipo', 'Tipo', 'required');
     $this->form_validation->set_rules('contenido', 'Contenido', 'required');
     if ($this->input->post('tipo') == 'certificado') {
         $this->form_validation->set_rules('titulo', 'Título', 'required');
         $this->form_validation->set_rules('subtitulo', 'Subtítulo', 'required');
         $this->form_validation->set_rules('servicio', 'Servicio', 'required');
         $this->form_validation->set_rules('servicio_url', 'URL del Servicio', 'required|prep_url');
         $this->form_validation->set_rules('firmador_nombre', 'Nombre del firmador');
         $this->form_validation->set_rules('firmador_cargo', 'Cargo del firmador');
         $this->form_validation->set_rules('firmador_servicio', 'Servicio del firmador');
         $this->form_validation->set_rules('firmador_imagen', 'Imagen de la firmas');
         $this->form_validation->set_rules('validez', 'Dias de validez', 'is_natural');
         $this->form_validation->set_rules('validez_habiles', 'Habiles');
     }
     $respuesta = new stdClass();
     if ($this->form_validation->run() == TRUE) {
         $documento->nombre = $this->input->post('nombre');
         $documento->tipo = $this->input->post('tipo');
         $documento->contenido = $this->input->post('contenido', false);
         $documento->tamano = $this->input->post('tamano');
         $documento->hsm_configuracion_id = $this->input->post('hsm_configuracion_id');
         if ($documento->tipo == 'certificado') {
             $documento->titulo = $this->input->post('titulo');
             $documento->subtitulo = $this->input->post('subtitulo');
             $documento->servicio = $this->input->post('servicio');
             $documento->servicio_url = $this->input->post('servicio_url');
             $documento->logo = $this->input->post('logo');
             $documento->timbre = $this->input->post('timbre');
             $documento->firmador_nombre = $this->input->post('firmador_nombre');
             $documento->firmador_cargo = $this->input->post('firmador_cargo');
             $documento->firmador_servicio = $this->input->post('firmador_servicio');
             $documento->firmador_imagen = $this->input->post('firmador_imagen');
             $documento->validez = $this->input->post('validez') == '' ? null : $this->input->post('validez');
             $documento->validez_habiles = $this->input->post('validez_habiles');
         }
         $documento->save();
         $respuesta->validacion = TRUE;
         $respuesta->redirect = site_url('backend/documentos/listar/' . $documento->Proceso->id);
     } else {
         $respuesta->validacion = FALSE;
         $respuesta->errores = validation_errors();
     }
     echo json_encode($respuesta);
 }

 public function actionUpload($id)
 {
     try {
         Yii::import("xupload.models.XUploadForm");
         //Here we define the paths where the files will be stored temporarily
         $path = realpath(Yii::app()->getBasePath() . "/../images/uploads/tmp/") . "/";
         $publicPath = Yii::app()->getBaseUrl() . "/../images/uploads/tmp/";
         //This is for IE which doens't handle 'Content-type: application/json' correctly
         header('Vary: Accept');
         if (isset($_SERVER['HTTP_ACCEPT']) && strpos($_SERVER['HTTP_ACCEPT'], 'application/json') !== false) {
             header('Content-type: application/json');
         } else {
             header('Content-type: text/plain');
         }
         //Here we check if we are deleting and uploaded file
         if (isset($_GET["_method"])) {
             if ($_GET["_method"] == "delete") {
                 if ($_GET["file"][0] !== '.') {
                     $file = $path . $_GET["file"];
                     if (is_file($file)) {
                         unlink($file);
                     }
                 }
                 echo json_encode(true);
             }
         } else {
             $model = new XUploadForm();
             $model->file = CUploadedFile::getInstance($model, 'file');
             //We check that the file was successfully uploaded
             if ($model->file !== null) {
                 //Grab some data
                 $model->mime_type = $model->file->getType();
                 $model->size = $model->file->getSize();
                 $model->name = $model->file->getName();
                 //(optional) Generate a random name for our file
                 $filename = microtime() . $model->name;
                 $filename .= "." . $model->file->getExtensionName();
                 if ($model->validate()) {
                     //Move our file to our temporary dir
                     if ($model->file->saveAs($path . $filename)) {
                         $modelDocto = new Documento();
                         $modelDocto->ruta = $filename;
                         $modelDocto->proyecto_did = $id;
                         $modelDocto->estatus_did = 1;
                         $modelDocto->save();
                     }
                     chmod($path . $filename, 0777);
                     //here you can also generate the image versions you need
                     //using something like PHPThumb
                     //Now we need to save this path to the user's session
                     if (Yii::app()->user->hasState('images')) {
                         $userImages = Yii::app()->user->getState('images');
                     } else {
                         $userImages = array();
                     }
                     $userImages[] = array("path" => $path . $filename, "thumb" => $path . $filename, "filename" => $filename, 'size' => $model->size, 'mime' => $model->mime_type, 'name' => $model->name);
                     Yii::app()->user->setState('images', $userImages);
                     //Now we need to tell our widget that the upload was succesfull
                     //We do so, using the json structure defined in
                     // https://github.com/blueimp/jQuery-File-Upload/wiki/Setup
                     echo json_encode(array(array("name" => $model->name, "type" => $model->mime_type, "size" => $model->size, "url" => $publicPath . $filename, "thumbnail_url" => $publicPath . "thumbs/{$filename}", "delete_url" => $this->createUrl("upload", array("_method" => "delete", "file" => $filename)), "delete_type" => "POST")));
                 } else {
                     //If the upload failed for some reason we log some data and let the widget know
                     echo json_encode(array(array("error" => $model->getErrors('file'))));
                     Yii::log("XUploadAction: " . CVarDumper::dumpAsString($model->getErrors()), CLogger::LEVEL_ERROR, "xupload.actions.XUploadAction");
                 }
             } else {
                 throw new CHttpException(500, "Could not upload file");
             }
         }
     } catch (Exception $e) {
         print_r($e);
     }
 }

 public function submit_upload_file()
 {
     if (Auth::check()) {
         $data["inside_url"] = Config::get('app.inside_url');
         $data["user"] = Session::get('user');
         $data["permisos"] = Session::get('permisos');
         if (in_array('side_nuevo_evento', $data["permisos"])) {
             // Validate the info, create rules for the inputs
             $attributes = array('archivo' => 'Documento');
             $messages = array();
             $rules = array('archivo' => 'required|max:15360|mimes:pdf,doc,docx,xls,xlsx,ppt,pptx');
             // Run the validation rules on the inputs from the form
             $validator = Validator::make(Input::all(), $rules, $messages, $attributes);
             // If the validator fails, redirect back to the form
             $ideventos = Input::get('ideventos');
             if ($validator->fails()) {
                 return Redirect::to('eventos/upload_file/' . $ideventos)->withErrors($validator)->withInput(Input::all());
             } else {
                 if (Input::hasFile('archivo')) {
                     $archivo = Input::file('archivo');
                     $rutaDestino = 'files/eventos/';
                     $nombreArchivo = $archivo->getClientOriginalName();
                     $nombreArchivoEncriptado = Str::random(27) . '.' . pathinfo($nombreArchivo, PATHINFO_EXTENSION);
                     $peso = $archivo->getSize();
                     $uploadSuccess = $archivo->move($rutaDestino, $nombreArchivoEncriptado);
                     /* Creo el documento */
                     $documento = new Documento();
                     $documento->titulo = $nombreArchivo;
                     $documento->idtipo_documentos = 1;
                     // ¡Que viva el hardcode!
                     $documento->nombre_archivo = $nombreArchivoEncriptado;
                     $documento->ruta = $rutaDestino;
                     $documento->peso = $peso;
                     $documento->save();
                     /* Creo la relación de evento con documento */
                     $documentos_evento = new DocumentosEvento();
                     $documentos_evento->ideventos = $ideventos;
                     $documentos_evento->iddocumentos = $documento->iddocumentos;
                     $documentos_evento->save();
                     /* Envio las notificaciones via e-mail a los voluntarios */
                     $evento = Evento::find($ideventos);
                     $emails_voluntarios = Asistencia::getUsersPorEvento($evento->ideventos)->get();
                     $emails = array();
                     foreach ($emails_voluntarios as $email_voluntario) {
                         $emails[] = $email_voluntario->email;
                     }
                     Mail::send('emails.eventDocumento', array('evento' => $evento, 'documento' => $documento), function ($message) use($emails, $evento) {
                         $message->to($emails)->subject('Se subió un nuevo documento de AFI Perú.');
                     });
                     //Enviar las push notifications a los voluntarios
                     $voluntarios = Asistencia::getUserPushInfoByEvento($evento->ideventos)->get();
                     foreach ($voluntarios as $voluntario) {
                         if ($voluntario->push_documents && $voluntario->uuid) {
                             $message = 'Se subió un nuevo documento de AFI Perú.';
                             Helpers::pushAPNS($voluntario->uuid, $message, 3);
                         }
                     }
                     // Enviar las push notifications (android) a los voluntarios
                     $gcm_tokens = Asistencia::getUsersToNotificateDocumentUploaded($ideventos)->get()->lists('gcm_token');
                     $title = 'AFI Perú - Nuevo documento';
                     $message = 'Se subió un nuevo documento de AFI Perú: ' . $documento->titulo;
                     $type = 3;
                     $m = ['title' => $title, 'message' => $message, 'type' => $type];
                     Helpers::pushGCM($gcm_tokens, $m);
                     // Llamo a la función para registrar el log de auditoria
                     $descripcion_log = "Se subió el documento con id {{$documento->iddocumentos}}";
                     Helpers::registrarLog(7, $descripcion_log);
                 }
                 Session::flash('message', 'Se subió correctamente el archivo.');
                 return Redirect::to('eventos/upload_file/' . $ideventos);
             }
         } else {
             // Llamo a la función para registrar el log de auditoria
             $descripcion_log = "Se intentó acceder a la ruta '" . Request::path() . "' por el método '" . Request::method() . "'";
             Helpers::registrarLog(10, $descripcion_log);
             Session::flash('error', 'Usted no tiene permisos para realizar dicha acción.');
             return Redirect::to('/dashboard');
         }
     } else {
         return View::make('error/error');
     }
 }

 public function submit_edit_adjudicacion_expediente()
 {
     if (Auth::check()) {
         $data["inside_url"] = Config::get('app.inside_url');
         $data["user"] = Session::get('user');
         // Verifico si el usuario es un Webmaster
         if ($data["user"]->idrol == 1 || $data["user"]->idrol == 2 || $data["user"]->idrol == 3 || $data["user"]->idrol == 4) {
             // Validate the info, create rules for the inputs
             $attributes = array('idoferta_ganador' => 'Oferta ganadora', 'archivo_contrato' => 'Archivo Adjunto Contrato', 'archivo_adicional' => 'Archivo Adjunto Adicional');
             $messages = array();
             $rules = array('idoferta_ganador' => 'required', 'archivo_contrato' => 'max:15360', 'archivo_adicional' => 'max:15360');
             // Run the validation rules on the inputs from the form
             $validator = Validator::make(Input::all(), $rules, $messages, $attributes);
             // If the validator fails, redirect back to the form
             $url = "adjudicacion_expediente/edit_adjudicacion_expediente" . "/" . Input::get('idexpediente_tecnico');
             if ($validator->fails()) {
                 return Redirect::to($url)->withErrors($validator)->withInput(Input::all());
             } else {
                 $expediente_tecnico = ExpedienteTecnico::withTrashed()->find(Input::get('idexpediente_tecnico'));
                 $expediente_tecnico->idoferta_ganador = Input::get('idoferta_ganador');
                 if (Input::hasFile('archivo_contrato')) {
                     $archivo_contrato = Input::file('archivo_contrato');
                     $rutaDestino_contrato = 'uploads/documentos/adquisicion/contrato/';
                     $nombre_archivo_contrato = $archivo_contrato->getClientOriginalName();
                     $nombre_archivo_encriptado_contrato = Str::random(27) . '.' . pathinfo($nombre_archivo_contrato, PATHINFO_EXTENSION);
                     $uploadSuccess = $archivo_contrato->move($rutaDestino_contrato, $nombre_archivo_encriptado_contrato);
                     $rutaArchivoEliminar = $expediente_tecnico->url_contrato . $expediente_tecnico->nombre_archivo_encriptado_contrato;
                     if (File::exists($rutaArchivoEliminar)) {
                         File::delete($rutaArchivoEliminar);
                     }
                     $expediente_tecnico->url_contrato = $rutaDestino_contrato;
                     $expediente_tecnico->nombre_archivo_contrato = $nombre_archivo_contrato;
                     $expediente_tecnico->nombre_archivo_encriptado_contrato = $nombre_archivo_encriptado_contrato;
                     $documento_contrato = new Documento();
                     $documento_contrato->nombre = $nombre_archivo_contrato;
                     $documento_contrato->autor = '';
                     $documento_contrato->codigo_archivamiento = $expediente_tecnico->codigo_archivamiento;
                     $documento_contrato->ubicacion = '';
                     $documento_contrato->idtipo_documento = 1;
                     $documento_contrato->idestado = 1;
                     $documento_contrato->url = $rutaDestino_contrato;
                     $documento_contrato->nombre_archivo = $nombre_archivo_contrato;
                     $documento_contrato->nombre_archivo_encriptado = $nombre_archivo_encriptado_contrato;
                     $documento_contrato->save();
                 }
                 if (Input::hasFile('archivo_adicional')) {
                     $archivo_documento_adicional = Input::file('archivo_adicional');
                     $rutaDestino_documento_adicional = 'uploads/documentos/adquisicion/documento_adicional/';
                     $nombre_archivo_documento_adicional = $archivo_documento_adicional->getClientOriginalName();
                     $nombre_archivo_encriptado_documento_adicional = Str::random(27) . '.' . pathinfo($nombre_archivo_documento_adicional, PATHINFO_EXTENSION);
                     $uploadSuccess = $archivo_documento_adicional->move($rutaDestino_documento_adicional, $nombre_archivo_encriptado_documento_adicional);
                     $rutaArchivoEliminar = $expediente_tecnico->url_documento_adicional . $expediente_tecnico->nombre_archivo_encriptado_documento_adicional;
                     if (File::exists($rutaArchivoEliminar)) {
                         File::delete($rutaArchivoEliminar);
                     }
                     $expediente_tecnico->url_documento_adicional = $rutaDestino_documento_adicional;
                     $expediente_tecnico->nombre_archivo_documento_adicional = $nombre_archivo_documento_adicional;
                     $expediente_tecnico->nombre_archivo_encriptado_documento_adicional = $nombre_archivo_encriptado_documento_adicional;
                 }
                 $expediente_tecnico->save();
                 Session::flash('message', 'Se registró correctamente la Adjudicación y Contrato Firmado.');
                 return Redirect::to($url);
             }
         } else {
             return View::make('error/error', $data);
         }
     } else {
         return View::make('error/error', $data);
     }
 }

$organismo->descripcion = 'Honorable concejo deliberante de la ciudad.';
$organismo->cupo = 1;
$organismo->save();
ImageManager::crearImagen('organis', $organismo->id, $organismo->nombre, array(32, 64, 160));
$funcionario = new Funcionario();
$funcionario->usuario()->associate($usuario);
$funcionario->organismo()->associate($organismo);
$funcionario->save();
$categoria = new Categoria();
$categoria->nombre = 'general';
$categoria->save();
///
$documento = new Documento();
$documento->descripcion = 'Se presenta una propuesta para modificar la actual regulación de alquileres.';
$documento->ultima_version = 1;
$documento->save();
$docVersion = new VersionDocumento();
$docVersion->version = 1;
$docVersion->documento()->associate($documento);
$docVersion->save();
$docParrafo = new ParrafoDocumento();
$docParrafo->cuerpo = '[u]Artículo 1 - PERÍODOS Y FORMA DE PAGO.[/u]';
$docParrafo->ubicacion = 0;
$docParrafo->version()->associate($docVersion);
$docParrafo->save();
$docParrafo = new ParrafoDocumento();
$docParrafo->cuerpo = 'El alquiler se paga en períodos mensuales. El período de pago corresponde al mes en que transcurre la ocupación del inmueble alquilado. La fecha de vencimiento para el pago del período correspondiente no podrá ser anterior al día diez (10) de cada mes. En caso de resolución anticipada, si la fecha de finalización del contrato no coincide con la fecha de cierre del período mensual de pago, se debe pagar la proporción que corresponda. Para ello se divide por treinta (30) el valor mensual del alquiler, multiplicándose el resultado por la cantidad de días a liquidar.';
$docParrafo->ubicacion = 1;
$docParrafo->version()->associate($docVersion);
$docParrafo->save();
$docParrafo = new ParrafoDocumento();

 public function submit_create_expediente_tecnico()
 {
     if (Auth::check()) {
         $data["inside_url"] = Config::get('app.inside_url');
         $data["user"] = Session::get('user');
         // Verifico si el usuario es un Webmaster
         if ($data["user"]->idrol == 1 || $data["user"]->idrol == 2 || $data["user"]->idrol == 3 || $data["user"]->idrol == 4) {
             // Validate the info, create rules for the inputs
             $attributes = array('codigo_compra' => 'Código de Compra', 'codigo_archivamiento' => 'Código de Archivamiento', 'idtipo_adquisicion_expediente' => 'Tipo de adquisicion', 'idtipo_compra_expediente' => 'Tipo de compra', 'idarea' => 'Departamento', 'descripcion' => 'Descripción', 'archivo_resolucion' => 'Archivo adjunto Resolución', 'archivo_tdr' => 'Archivo adjunto Término de referencia', 'archivo_bases' => 'Archivo adjunto Bases');
             $messages = array();
             $rules = array('codigo_compra' => 'required|unique:expediente_tecnico', 'codigo_archivamiento' => 'required', 'idtipo_adquisicion_expediente' => 'required', 'idtipo_compra_expediente' => 'required', 'idarea' => 'required', 'descripcion' => 'required|max:255', 'archivo_resolucion' => 'required|max:15360', 'archivo_tdr' => 'max:15360', 'archivo_bases' => 'max:15360');
             // Run the validation rules on the inputs from the form
             $validator = Validator::make(Input::all(), $rules, $messages, $attributes);
             // If the validator fails, redirect back to the form
             if ($validator->fails()) {
                 return Redirect::to('expediente_tecnico/create_expediente_tecnico')->withErrors($validator)->withInput(Input::all());
             } else {
                 $rutaDestino_resolucion = '';
                 $nombre_archivo_resolucion = '';
                 $nombre_archivo_resolucion_encriptado = '';
                 $rutaDestino_tdr = '';
                 $nombre_archivo_tdr = '';
                 $nombre_archivo_tdr_encriptado = '';
                 $rutaDestino_bases = '';
                 $nombre_archivo_bases = '';
                 $nombre_archivo_bases_encriptado = '';
                 if (Input::hasFile('archivo_resolucion')) {
                     $archivo_resolucion = Input::file('archivo_resolucion');
                     $rutaDestino_resolucion = 'uploads/documentos/adquisicion/resolucionExpediente/';
                     $nombre_archivo_resolucion = $archivo_resolucion->getClientOriginalName();
                     $nombre_archivo_resolucion_encriptado = Str::random(27) . '.' . pathinfo($nombre_archivo_resolucion, PATHINFO_EXTENSION);
                     $uploadSuccess = $archivo_resolucion->move($rutaDestino_resolucion, $nombre_archivo_resolucion_encriptado);
                 }
                 if (Input::hasFile('archivo_tdr')) {
                     $archivo_tdr = Input::file('archivo_tdr');
                     $rutaDestino_tdr = 'uploads/documentos/adquisicion/tdrExpediente/';
                     $nombre_archivo_tdr = $archivo_tdr->getClientOriginalName();
                     $nombre_archivo_tdr_encriptado = Str::random(27) . '.' . pathinfo($nombre_archivo_tdr, PATHINFO_EXTENSION);
                     $uploadSuccess = $archivo_tdr->move($rutaDestino_tdr, $nombre_archivo_tdr_encriptado);
                     $documento_tdr = new Documento();
                     $documento_tdr->nombre = $nombre_archivo_tdr;
                     $documento_tdr->autor = '';
                     $documento_tdr->codigo_archivamiento = Input::get('codigo_archivamiento');
                     $documento_tdr->ubicacion = '';
                     $documento_tdr->idtipo_documento = 7;
                     $documento_tdr->idestado = 1;
                     $documento_tdr->url = $rutaDestino_tdr;
                     $documento_tdr->nombre_archivo = $nombre_archivo_tdr;
                     $documento_tdr->nombre_archivo_encriptado = $nombre_archivo_tdr_encriptado;
                     $documento_tdr->save();
                 }
                 if (Input::hasFile('archivo_bases')) {
                     $archivo_bases = Input::file('archivo_bases');
                     $rutaDestino_bases = 'uploads/documentos/adquisicion/basesExpediente/';
                     $nombre_archivo_bases = $archivo_bases->getClientOriginalName();
                     $nombre_archivo_bases_encriptado = Str::random(27) . '.' . pathinfo($nombre_archivo_bases, PATHINFO_EXTENSION);
                     $uploadSuccess = $archivo_bases->move($rutaDestino_bases, $nombre_archivo_bases_encriptado);
                 }
                 $expediente_tecnico = new ExpedienteTecnico();
                 $expediente_tecnico->codigo_compra = Input::get('codigo_compra');
                 $expediente_tecnico->codigo_archivamiento = Input::get('codigo_archivamiento');
                 $expediente_tecnico->idtipo_adquisicion_expediente = Input::get('idtipo_adquisicion_expediente');
                 $expediente_tecnico->idtipo_compra_expediente = Input::get('idtipo_compra_expediente');
                 if (Input::get('select_nombre_equipo') == -1 || Input::get('select_nombre_equipo') === '') {
                     $expediente_tecnico->otros_equipos = Input::get('otros_equipos');
                     $expediente_tecnico->nombre_equipo = '';
                 } else {
                     $expediente_tecnico->nombre_equipo = Input::get('nombre_equipo');
                 }
                 $expediente_tecnico->idarea = Input::get('idarea');
                 $expediente_tecnico->idservicio = Input::get('idservicio');
                 $expediente_tecnico->descripcion = Input::get('descripcion');
                 $expediente_tecnico->url_resolucion = $rutaDestino_resolucion;
                 $expediente_tecnico->nombre_archivo_resolucion = $nombre_archivo_resolucion;
                 $expediente_tecnico->nombre_archivo_encriptado_resolucion = $nombre_archivo_resolucion_encriptado;
                 $expediente_tecnico->url_tdr = $rutaDestino_tdr;
                 $expediente_tecnico->nombre_archivo_tdr = $nombre_archivo_tdr;
                 $expediente_tecnico->nombre_archivo_encriptado_tdr = $nombre_archivo_tdr_encriptado;
                 $expediente_tecnico->url_bases = $rutaDestino_bases;
                 $expediente_tecnico->nombre_archivo_bases = $nombre_archivo_bases;
                 $expediente_tecnico->nombre_archivo_encriptado_bases = $nombre_archivo_bases_encriptado;
                 $expediente_tecnico->idresponsable = $data["user"]->id;
                 $expediente_tecnico->estado_evaluacion_ofertas_finalizada = 0;
                 if (Input::get('idtipo_adquisicion_expediente') == 1) {
                     // si se selecciona Bienes
                     if (Input::get('select_nombre_equipo') != '') {
                         if (!(Input::get('select_nombre_equipo') == -1 && Input::get('otros_equipos') == '')) {
                             $expediente_tecnico->save();
                             Session::flash('message', 'Se registró correctamente el Expediente Técnico.');
                             return Redirect::to('expediente_tecnico/create_expediente_tecnico');
                         } else {
                             Session::flash('error', 'Debe especificar el Nombre de Equipo en el campo Otros Equipos.');
                             return Redirect::to('expediente_tecnico/create_expediente_tecnico')->withInput(Input::all());
                         }
                     } else {
                         Session::flash('error', 'El campo Nombre de Equipo es requerido.');
                         return Redirect::to('expediente_tecnico/create_expediente_tecnico')->withInput(Input::all());
                     }
                 } else {
                     $expediente_tecnico->save();
//.........这里部分代码省略.........

$conteni->autor()->associate($usuario);
$conteni->contenible()->associate($problem);
$conteni->save();
$propues = new Propuesta();
$propues->cuerpo = 'Propuesta creada para hacer pruebas.';
$propues->save();
$conteni = new Contenido();
$conteni->titulo = 'Primer Propuesta';
$conteni->categoria_id = 1;
$conteni->autor()->associate($usuario);
$conteni->contenible()->associate($propues);
$conteni->save();
$documen = new Documento();
$documen->descripcion = 'Esta es una descripcion.';
$documen->ultima_version = 1;
$documen->save();
$docVers = new VersionDocumento();
$docVers->version = 1;
$docVers->documento()->associate($documen);
$docVers->save();
$docParr = new ParrafoDocumento();
$docParr->cuerpo = 'Documento creado para hacer pruebas.';
$docParr->ubicacion = 0;
$docParr->version()->associate($docVers);
$docParr->save();
$conteni = new Contenido();
$conteni->titulo = 'Primer Documento';
$conteni->categoria_id = 1;
$conteni->autor()->associate($usuario);
$conteni->contenible()->associate($documen);
$conteni->save();