Ist diese korrekte Art, wie URL im Auftriebsgerüst mit Ruhestand umzugehen?

Question

Wenn ich eine URL habe wie http: // localhost/test/bearbeiten/{id} und ich möchte die {id} -Transformation in einen Parameter anstelle des URL -Pfadteils.

Ist es der beste Weg, dies zu tun, indem Sie ein Menü mit Umschreibenerquest erstellen? Weil ich es ein wenig Kessel fand, wenn ich ein solches Lot -URL -Muster habe.

val menu = Menu(new Loc[Unit] {

    override def name = "Test"
    override def text = "Test"
    override def link = (List ("Test"), true)
    override def params = Nil
    override def defaultValue = Full(())


    def isTarget (path: ParsePath) = path match {
        case ParsePath (List("Test", "edit", id), _, _, _) => true

        case _ => false
    }

    override def rewrite = Full ( NamedPF("Test") {
        case RewriteRequest (path, _, _) if isTarget(path) => 
             RewriteResponse(List("Test", "edit"),  
                             Map("id" -> "1024")) -> ()

    })
})

Answer 1

In Ihrem boot.scala benötigen Sie den folgenden (aus dem tatsächlichen Arbeitscode!) Beachten Sie, dass jeder Umschreibungsweg in Ihrer Sitemap sein muss.

LiftRules.rewrite.append {
  case RewriteRequest(ParsePath(List("shopInfo", "view", id), _, _, _), _, _) => RewriteResponse("shopInfo" :: "view" :: Nil, Map("id" -> id))
  case RewriteRequest(ParsePath(List("shopInfo", "orders", id), _, _, _), _, _) => RewriteResponse("shopInfo" :: "orders" :: Nil, Map("id" -> id))
  case RewriteRequest(ParsePath(List("shopInfo", "sync", id), _, _, _), _, _) => RewriteResponse("shopInfo" ::  "sync" :: Nil, Map("id" -> id))
  case RewriteRequest(ParsePath(List("shopInfo", "delete", id), _, _, _), _, _) => RewriteResponse("shopInfo" :: "delete" :: Nil, Map("id" -> id))
  case RewriteRequest(ParsePath(List("shopInfo", "edit", id), _, _, _), _, _) => RewriteResponse("shopInfo" :: "edit" :: Nil, Map("id" -> id))
}

Answer 2

Vielen Dank für alle Ihre Antworten.

Was ich am meisten will, ist, dass diese Dinge mit dem Menü eng zusammenschreiben, sodass ich sie nur in meiner Modellklasse einrichten konnte, wie das Crudify -Merkmal.

Am Ende habe ich selbst eine Unterklasse von LOC erstellt, um diese Umschreibungsregeln zu verarbeiten, und ich fand, dass sie ziemlich gut funktioniert und die Dinge viel einfacher machen (zumindest für mich), also poste ich den Code hier.

Fühlen Sie sich frei, dies zu kopieren, wenn jemand es braucht

/**
 *  A RESTful-like URL handling Loc
 *
 *  If you have the following templates:
 *
 *    * webapps/item/edit.html
 *    * webapps/item/view.html
 *  
 *  You want the following URL map to corresponding template with 
 *  last path component as a S parameter.
 *
 *    http://localhost/item/edit/1  to  http://localhost/item/edit
 *    http://localhost/item/view/1  to  http://localhost/item/view
 *
 *  You could create a Menu with this Loc class in your Model object.
 *
 *  <code>
 *  object Item extends Item with LongKeyedMetaMapper[Item] 
 *  {
 *      // Other methods here...
 *
 *      def menu () {  
 *
 *          // What methods do we have?
 *          val methods = List ("view", "edit")
 *
 *          val parameterName = "itemID"
 *          val itemLoc = new RESTfulLoc("Item", List("item"), "Item", 
 *                                       methods, parameterName)
 *
 *          Menu (itemLoc)
 *      }
 *  }
 *  </code>
 *
 *  Now add the menu to SiteMap in Boot.boot
 *
 *  <code>
 *  class Boot {
 *      def boot () {
 *          
 *          val entries = Item.menu ::  Nil
 *
 *          LiftRules.setSiteMap(SiteMap(entries:_*))
 *      }
 *  }
 *  </code>
 *
 *
 *  Finally, You could access the parameter in your snippet with 
 *  S.param("itemID")
 *
 */
class RESTfulLoc (val name: String, val path: List[String],
                  val text: LinkText[Unit], val methods: List[String],
                  val parameterName: String,
                  val locParams: LocParam[Unit]*) extends Loc[Unit] 
{
    override val defaultValue = Full(())
    override val params = locParams.toList
    override val link: Link[Unit] = (List(path.first), true)

    def this (name: String, path: List[String], text: LinkText[Unit], 
              methods: List[String], locParams: LocParam[Unit]*) = 
    {
        this (name, path, text, methods, "id", locParams:_*)
    }

    private def isTarget (path: ParsePath) = 
    {
        path.partPath -- this.path match {
            case List (action, id) => {
                (methods contains action) && id != "index"
            }
            case _ => false
        }
    }

    override def rewrite = Full (NamedPF("RESTfulLoc") 
    {
        case RewriteRequest (path, _, _) if isTarget(path) => {
             val parameter = path.partPath.last
             val action    = path.partPath.init
             val data      = Map (parameterName -> parameter)

             RewriteResponse(action, data) -> ()
        }
    })
}

Answer 3

Ich bin auf diesen Beitrag gestoßen, weil ich die gleiche Frage hatte. Die Antwort von Jim Barrows ist korrekt (und am einfachsten), aber ohne irgendeine Erklärung fiel es für mich schwer, zu grok, was dieser Code tut. Eine detaillierte Erklärung, warum Jims Lösung Arbeiten im LIFT -Buch online finden (http://groups.google.com/group/the-lift-book). Schauen Sie sich Abschnitt 3.12 mit dem Titel "URL Rewriting" an, das Sie Schritt für Schritt durch den Bau einer erholsamen URL führt.

Auf jeden Fall sollte es nicht erforderlich sein, einen benutzerdefinierten LOC zu schreiben, um den gewünschten Effekt zu erzielen.

Viel Glück!

Answer 4

Entschuldigung, der obige Kommentar ist ein chaotischer Liitle.

Das Problem ist, dass, wenn ich eine Vorlage mit dem Namen edit.html unter WebApp/Test habe. Dies ist die Vorlage, die ich zum Bearbeiten eines Elements verwendet.

Und ich habe eine Menüinstanz wie Folgendes:

Menu (Loc("Test", List("Test") -> true, "Test"))

Es würde nur mit URL übereinstimmen wie http: // localhost/test/bearbeiten, nicht so etwas wie http: // localhost/test/edit/1

Answer 5

Warum möchten Sie es in Abfrageparam ändern? Ist es aus technischen oder Frameworkgründen?

Die {id} gehört meiner Ansicht nach dem URI -Pfad, sie identifiziert eine eindeutige Ressource und ich mag es, diese Informationen im Pfad zu behalten. Die URIs kann jede Art von Zeichenzeichenfolge sein (so würde der Parameter von Abfragen auch funktionieren), aber ich würde die URIs so eng wie möglich ressourcen-id modellieren.