Пример Razor — отображение изображений

Предположим, у вас есть 3 изображения в папке изображений, и вы хотите отображать изображения динамически. по выбору пользователей.

Это легко сделать с помощью небольшого кода Razor.

Если у вас есть изображение под названием «Photo1.jpg» в папке изображений в Интернете сайт, вы можете отображать изображение, используя HTML элемент вроде этого:

Пример ниже показывает, как отобразить выбранный картинка, которую выбирает пользователь из раскрывающегося списка:

Бритва, пример

@ {
var imagePath = «»;
if (Запрос [«Выбор»]! = null)
{imagePath = «images /» + Request [«Choice»];}
}

Показать изображения

Объяснение примера

Сервер создает переменную с именем imagePath .

На HTML-странице есть раскрывающийся список (элемент ) с именем Choice . Он позволяет пользователю выбрать понятное имя (например, Photo 1 ) и передать файл имя (например, Photo1.jpg ), когда страница отправляется на веб-сервер.

Код Razor считывает значение Choice по запросу Request [«Choice»] . Если он имеет значение, код создает путь к изображению images / Photo1.jpg и сохраняет его в переменная imagePath .

На HTML-странице есть элемент для отображения изображения. Атрибут src установлен в значение imagePath переменная при отображении страницы.

Элемент находится в блоке if для предотвратить попытку отображения изображения без имени (например, когда страница отображается).

web2py — Формы и валидаторы

Формы и валидаторы

Существует четыре различных способа создания форм в web2py:

• FORM обеспечивает низкоуровневую реализацию в терминах помощников HTML. Объект FORM может быть сериализован в HTML и знает о полях, которые он содержит. Объект FORM знает, как проверять отправленные значения формы.
• SQLFORM предоставляет высокоуровневый API для создания форм создания, обновления и удаления из существующей таблицы базы данных.
• SQLFORM.factory — это уровень абстракции поверх SQLFORM , позволяющий использовать преимущества функций генерации форм, даже если база данных отсутствует.Он генерирует форму, очень похожую на SQLFORM из описания таблицы, но без необходимости создавать таблицу базы данных.
• CRUD методы. Они функционально эквивалентны SQLFORM и основаны на SQLFORM, но обеспечивают более компактную нотацию; CRUD теперь устарел и заменен SQLFORM.grid () и SQLFORM.smartgrid () .

Все эти формы самооценки и, если ввод не проходит валидацию, они могут изменять себя и добавлять сообщения об ошибках. В формах можно запрашивать проверенные переменные и сообщения об ошибках, сгенерированные при проверке.

Произвольный HTML-код можно вставить в форму или извлечь из нее с помощью помощников.

FORM и SQLFORM являются помощниками, и ими можно управлять так же, как DIV . Например, вы можете установить стиль формы:

 form = SQLFORM (..)
form ['_ style'] = 'граница: сплошной черный 1px'
 

ФОРМА

форма

принимает

Рассмотрим в качестве примера приложение test со следующим значением «default.py «контроллер:

 def display_form ():
    form = FORM ('Ваше имя:', INPUT (_name = 'name'), INPUT (_type = 'submit'))
    return dict (form = form)
 

и связанный вид «default / display_form.html»:

 {{extend 'layout.html'}}
 
 Форма ввода 
 

Ваше имя:

Отправленные переменные

Это обычная HTML-форма, которая запрашивает имя пользователя. Когда вы заполняете форму и нажимаете кнопку «Отправить», форма отправляется автоматически, а переменная request.vars.name вместе с предоставленным ей значением отображается внизу.

Вы можете создать ту же форму с помощью помощников. Это можно сделать в представлении или в действии. Поскольку web2py обработал форму в действии, лучше определить форму в самом действии.

Вот новый контроллер:

 def display_form ():
   form = FORM ('Ваше имя:', INPUT (_name = 'name'), INPUT (_type = 'submit'))
   return dict (form = form)
 

и связанный с ним default / display_form.html «view:

 {{extend 'layout.html'}}
 
 Форма ввода 
 
{{= форма}}
 
 Отправленные переменные 
 
{{= КРАСОТА (request.vars)}}
 

Код на данный момент эквивалентен предыдущему коду, но форма генерируется оператором {{= form}} , который сериализует объект FORM .

Теперь мы добавляем еще один уровень сложности, добавляя проверку и обработку формы.

Измените контроллер следующим образом:

 def display_form ():
    form = FORM ('Ваше имя:',
              INPUT (_name = 'name', требуется = IS_NOT_EMPTY ()),
              ВХОД (_type = 'отправить'))
    если форма.принимает (запрос, сеанс):
        response.flash = 'форма принята'
    elif form.errors:
        response.flash = 'в форме есть ошибки'
    еще:
        response.flash = 'заполните форму'
    return dict (form = form)
 

и связанный вид «default / display_form.html»:

 {{extend 'layout.html'}}
 
 Форма ввода 
 
{{= форма}}
 
 Отправленные переменные 
 
{{= КРАСОТА (request.vars)}}
 
 Допустимые переменные 
 
{{= КРАСОТА (form.vars)}}
 
 Ошибки в форме 
 
{{= КРАСОТА (форма.ошибки)}}
 

Обратите внимание, что:

• В действии мы добавили валидатор requires = IS_NOT_EMPTY () для поля ввода «name».
• В действии мы добавили вызов к form.accepts (..)
• В представлении мы печатаем form.vars и form.errors , а также форму и request.vars .

Вся работа выполняется методом принимает метод объекта form . Он фильтрует запрос .vars согласно заявленным требованиям (выраженным валидаторами). принимает сохраняет те переменные, которые проходят проверку, в form.vars . Если значение поля не соответствует требованиям, провалившийся валидатор возвращает ошибку, и ошибка сохраняется в форме .errors . И form.vars , и form.errors — это gluon.storage.Storage объектов, похожих на request.vars . Первый содержит значения, прошедшие проверку, например:

Второй содержит ошибки, например:

 форма.errors.name = "Не может быть пустым!"
 

Полная подпись метода принимает метод :

onvalidation

 form. accepts (vars, session = None, formname = 'default',
             keepvalues ​​= False, onvalidation = None,
             dbio = True, hideerror = False):
 

Значение дополнительных параметров поясняется в следующих подразделах.

Первым аргументом может быть request.vars или request.get_vars или request.post_vars или просто запрос . Последнее эквивалентно принятию в качестве входных данных request.post_vars .

принимает , функция возвращает Истина, , если форма принята, и Ложь, в противном случае. Форма не принимается, если в ней есть ошибки или если она не была отправлена ​​(например, при первом отображении).

Вот как эта страница выглядит при первом отображении:

Вот как она выглядит при недопустимой отправке:

Вот как она выглядит на действительной отправке:

Процесс и проверить методы

Ярлык для формы

. принимает (request.post_vars, session, ...)
 

это

 форма. Процесс (...). Принято
 

последний не нуждается в аргументах запроса и сеанса (хотя вы можете указать их по желанию). он также отличается от , принимает , потому что возвращает саму форму. Внутренне процесс , вызовы процесса , принимает и передает ему свои аргументы. Значение, возвращаемое функцией accept, сохраняется в форме .accepted .

Функция процесса принимает некоторый дополнительный аргумент, который принимает не принимает:

• message_onsuccess
• onsuccess : если равно ‘flash’ (по умолчанию) и форма принята, будет мигать вышеуказанное сообщение message_onsuccess
• message_onfailure
• onfailure : если он равен ‘flash’ (по умолчанию) и форма не прошла проверку, будет мигать вышеуказанное сообщение message_onfailure
• следующий указывает, куда перенаправить пользователя после формы принято.

onsuccess и onfailure могут быть функциями типа лямбда-форма: do_something (form) .

— это ярлык для

 form.process (..., dbio = False) .accepted
 

Условные поля

Бывают случаи, когда вы хотите, чтобы поле отображалось только при выполнении условия. Например, рассмотрим следующую модель:

  db.define_table ('покупка', Поле ('have_coupon', 'boolean'), Поле ('coupon_code'))  

Вы хотите отобразить поле coupon_code , если и только если отмечено поле have_coupon .Это можно сделать в JavaScript. web2py может помочь вам, сгенерировав для вас этот JavaScript. Вам просто нужно объявить, что поле является условным для выражения, используя поле show_if attribute:

  def index ():
    db.purchase.coupon_code.show_if = (db.purchase.have_coupon == True)
    form = SQLFORM (db.purchase) .process ()
    return dict (form = form)  

Значение show_if является запросом и использует тот же синтаксис DAL, который вы используете для запросов к базе данных. Разница в том, что этот запрос не отправляется в базу данных, а преобразуется в JavaScript и отправляется в браузер, где он выполняется, когда пользователь редактирует форму.

Скрытые поля

Когда вышеуказанный объект формы сериализуется с помощью {{= form}} , и из-за того, что предыдущий вызов принимает метод , теперь это выглядит так:

 

ваше имя:





 

Обратите внимание на наличие двух скрытых полей: «_formkey» и «_formname».Их присутствие запускается вызовом , принимает , и они играют две разные важные роли:

• Скрытое поле с именем «_formkey» — это одноразовый токен, который web2py использует для предотвращения двойной отправки форм. Значение этого ключа генерируется, когда форма сериализуется и сохраняется в сеансе . При отправке формы это значение должно совпадать, иначе принимает возвращает Ложь без ошибок, как если бы форма не была отправлена ​​вообще.Это связано с тем, что web2py не может определить, правильно ли была отправлена ​​форма.
• Скрытое поле с именем «_formname» генерируется web2py в качестве имени для формы, но это имя можно переопределить. Это поле необходимо для разрешения страниц, содержащих и обрабатывающих несколько форм. web2py различает разные отправленные формы по их именам.
• Необязательные скрытые поля, указанные как FORM (..., hidden = dict (...)) .

Роль этих скрытых полей и их использование в настраиваемых формах и страницах с несколькими формами обсуждается более подробно позже в этой главе.

Если форма выше отправлена ​​с пустым полем «имя», форма не проходит проверку. Когда форма снова сериализуется, она выглядит так:

 

ваше имя:

 не может быть пустым! 




 

Обратите внимание на наличие DIV класса «error» в сериализованной форме. web2py вставляет это сообщение об ошибке в форму, чтобы уведомить посетителя о поле, которое не прошло проверку. принимает метод при отправке, определяет, что форма отправлена, проверяет, является ли поле «имя» пустым и требуется ли оно, и в конечном итоге вставляет сообщение об ошибке от валидатора в форму.

Предполагается, что базовое представление layout.html будет обрабатывать DIV класса «error». Макет по умолчанию использует эффекты jQuery, чтобы ошибки появлялись и скользили вниз с красным фоном.См. Главу 11 для более подробной информации.

keepvalues ​​

keepvalues ​​

Необязательный аргумент keepvalues ​​ сообщает web2py, что делать, когда форма принята и нет перенаправления, поэтому та же форма отображается снова. По умолчанию форма очищена. Если для параметра keepvalues ​​ задано значение True , форма предварительно заполняется ранее вставленными значениями. Это полезно, когда у вас есть форма, которую предполагается многократно использовать для вставки нескольких похожих записей.

dbio

dbio

Если для аргумента dbio задано значение False , web2py не будет выполнять вставку / обновление БД после принятия формы.

hideerror

hideerror

Если для hideerror установлено значение Истинно и форма содержит ошибки, они не будут отображаться при визуализации формы (отображать их из формы придется вам. ошибки как-то).

onvalidation

Аргумент onvalidation может иметь значение None или может быть функцией, которая принимает форму и ничего не возвращает.Такая функция будет вызываться и передавать форму сразу после проверки (если проверка проходит) и до того, как произойдет что-либо еще. Эта функция имеет несколько целей: например, для выполнения дополнительных проверок формы и, в конечном итоге, добавления ошибок в форму, или для вычисления значений некоторых полей на основе значений других полей, или для запуска какого-либо действия (например, отправка электронного письма). ) перед созданием / обновлением записи.

Вот пример:

 db.define_table ('числа',
    Поле ('а', 'целое'),
    Поле ('b', 'целое'),
    Поле ('c', 'integer', читаемый = False, записываемый = False))

def my_form_processing (форма):
    c = форма.vars.a * form.vars.b
    если c <0:
       form.errors.b = 'a * b не может быть отрицательным'
    еще:
       form.vars.c = c

def insert_numbers ():
   form = SQLFORM (db.numbers)
   если form.process (onvalidation = my_form_processing) .accepted:
       session.flash = 'запись вставлена'
       перенаправление (URL ())
   return dict (form = form)
 

Обнаружить изменение записи

При заполнении формы для редактирования записи существует небольшая вероятность того, что другой пользователь может одновременно редактировать ту же запись.Поэтому, когда мы сохраняем запись, мы хотим проверить возможные конфликты. Это можно сделать:

 db.define_table ('dog', Field ('name'))

def edit_dog ():
    dog = db. dog (request.args (0)) или перенаправление (URL ('error'))
    form = SQLFORM (db.dog, собака)
    form.process (detect_record_change = True)
    если form.record_changed:
        # сделай что-нибудь
    elif form.accepted:
        # сделай что-нибудь еще
    еще:
        # ничего не делать
    return dict (form = form)
 

record_changed работает только с SQLFORM, но не с FORM.

Формы и перенаправление

Наиболее распространенный способ использования форм - это самостоятельная отправка, так что отправленные переменные поля обрабатываются тем же действием, которое сгенерировало форму. После того, как форма принята, необычно снова отображать текущую страницу (что мы делаем здесь только для простоты). Чаще всего перенаправляют посетителя на «следующую» страницу.

Вот новый пример контроллера:

 def display_form ():
    form = FORM ('Ваше имя:',
              INPUT (_name = 'name', требуется = IS_NOT_EMPTY ()),
              ВХОД (_type = 'отправить'))
    если форма. process (). принято:
        session.flash = 'форма принята'
        перенаправление (URL ('следующий'))
    elif form.errors:
        response.flash = 'в форме есть ошибки'
    еще:
        response.flash = 'заполните форму'
    return dict (form = form)

def next ():
    return dict ()
 

Чтобы установить вспышку на следующей странице вместо текущей, вы должны использовать session.flash вместо response.flash . web2py перемещает первое во второе после перенаправления. Обратите внимание, что с использованием session.flash требует, чтобы вы не выполняли session.forget () .

Несколько форм на странице

имя формы

Содержание этого раздела применимо как к объектам FORM , так и к объектам SQLFORM . Возможно иметь несколько форм на странице, но вы должны позволить web2py различать их. Если они получены SQLFORM из разных таблиц, то web2py автоматически присваивает им разные имена; в противном случае вам нужно явно дать им разные имена форм. Вот пример:

 def two_forms ():
    form1 = FORM (INPUT (_name = 'name', требует = IS_NOT_EMPTY ()),
                 INPUT (_type = 'submit'), _name = 'form_one')
    form2 = FORM (INPUT (_name = 'name', требует = IS_NOT_EMPTY ()),
                 INPUT (_type = 'submit'), _name = 'form_two')
    если form1.process (formname = 'form_one'). принято:
        response.flash = 'форма принята'
    если form2.process (formname = 'form_two'). принято:
        response.flash = 'вторая форма принята'
    return dict (form1 = form1, form2 = form2)
 

, и вот результат, который он выдает:

Когда посетитель отправляет пустую форму1, только form1 отображает ошибку; если посетитель отправляет пустую форму2, только форма2 отображает сообщение об ошибке.

Совместное использование форм

Содержание этого раздела применимо как к объектам FORM , так и к объектам SQLFORM . То, что мы обсуждаем здесь, возможно, но не рекомендуется, так как всегда полезно иметь формы, которые отправляются самостоятельно. Однако иногда у вас нет выбора, потому что действие, которое отправляет форму, и действие, которое ее получает, принадлежат разным приложениям.

Можно создать форму, которая отправляет другое действие. Это делается путем указания URL-адреса действия обработки в атрибутах объекта FORM или SQLFORM .Например:

 form = FORM (INPUT (_name = 'name', requires = IS_NOT_EMPTY ()),
        INPUT (_type = 'submit'), _action = URL ('page_two'))

def page_one ():
    return dict (form = form)

def page_two ():
    если form.process (session = None, formname = None) .accepted:
         response.flash = 'форма принята'
    еще:
         response.flash = 'в форме была ошибка'
    return dict ()
 

Обратите внимание, что, поскольку и page_one, и page_two используют одну и ту же форму , мы определили ее только один раз, поместив ее вне всех действий, чтобы не повторяться.Общая часть кода в начале контроллера выполняется каждый раз перед передачей управления вызываемому действию.

Поскольку page_one не вызывает процесс (и не принимает ), форма не имеет имени и ключа, поэтому вы должны передать session = None и установить formname = None в процессе , или форма не будет проверяться, когда "page_two" ее получит.

Добавление кнопок в ФОРМЫ

Обычно форма содержит единственную кнопку отправки.Часто требуется добавить кнопку «назад», которая вместо отправки формы перенаправляет посетителя на другую страницу.

add_button

Это можно сделать с помощью метода add_button :

 form.add_button ('Back', URL ('other_page'))
 

В форму можно добавить несколько кнопок. Аргументы add_button - это значение кнопки (ее текст) и URL-адрес для перенаправления. (См. Также аргумент кнопок для SQLFORM, который обеспечивает более мощный подход)

Подробнее о манипуляциях с FORM

Как обсуждалось в главе «Представления», FORM является помощником HTML. Помощниками можно управлять как списками Python и как словарями, что позволяет создавать и изменять во время выполнения.

SQLFORM

Теперь мы переходим на следующий уровень, предоставляя приложению файл модели:

 db = DAL ('sqlite: //storage.sqlite')
db.define_table ('человек', Поле ('имя', требуется = IS_NOT_EMPTY ()))
 

Измените контроллер следующим образом:

 def display_form ():
   form = SQLFORM (db.person)
   если form.process (). принято:
       ответ.flash = 'форма принята'
   elif form.errors:
       response.flash = 'в форме есть ошибки'
   еще:
       response.flash = 'заполните форму'
   return dict (form = form)
 

Вид не нужно менять.

В новом контроллере вам не нужно строить FORM , поскольку конструктор SQLFORM построил его из таблицы db.person , определенной в модели. Эта новая форма после сериализации выглядит так:

 

  <таблица>
    
        <метка
                  for = "person_name"> Ваше имя:  
         
        
    
    
        
         
        
    
  
  
  

 

Автоматически созданная форма сложнее предыдущей низкоуровневой формы. Прежде всего, он содержит таблицу строк, в каждой строке по три столбца. Первый столбец содержит метки полей (как определено из db.person ), второй столбец содержит поля ввода (и в конечном итоге сообщения об ошибках), а третий столбец является необязательным и поэтому пустым (он может быть заполнен полями в конструкторе SQLFORM ).

Все теги в форме имеют имена, производные от имени таблицы и поля. Это позволяет легко настраивать форму с помощью CSS и JavaScript.Эта возможность обсуждается более подробно в Главе 11.

Более важно то, что теперь принимает метод , делает гораздо больше работы за вас. Как и в предыдущем случае, он выполняет проверку ввода, но дополнительно, если ввод проходит проверку, он также выполняет вставку новой записи в базу данных и сохраняет в form.vars.id уникальный «идентификатор» новой запись.

Объект SQLFORM также автоматически обрабатывает поля «загрузки», сохраняя загруженные файлы в папку «загрузки» (после их безопасного переименования во избежание конфликтов и предотвращения атак обхода каталогов) и сохраняет их имена (их новые имена) в соответствующее поле в базе данных. После обработки формы новое имя файла доступно в form.vars.fieldname (т. Е. Оно заменяет объект cgi.FieldStorage в request.vars.fieldname ), поэтому вы можете легко ссылаться на новое имя сразу после загрузки.

Предупреждение: длина поля по умолчанию - 512 символов. Если файловая система не поддерживает такие длинные имена файлов, она может генерировать имена, которые вызовут ошибку при попытке их создания. Это можно решить, установив поле (..., length = ...) для подтверждения значения. Также обратите внимание, что это может привести к усечению кодировки исходного имени файла и может оказаться невозможным восстановить его после загрузки загруженного файла.

A SQLFORM отображает «логические» значения с флажками, «текстовые» значения с текстовыми полями, значения, которые должны быть в определенном наборе или базу данных с раскрывающимися списками, а также поля «загрузки» со ссылками, которые позволяют пользователям загружать загруженные файлы. Он скрывает поля «blob», поскольку предполагается, что они обрабатываются по-разному, см. Пример в разделе «Подробнее о загрузках» в главе 6.

Например, рассмотрим следующую модель:

 db.define_table ('person',
    Поле ('имя', требуется = IS_NOT_EMPTY ()),
    Поле ('женат', 'логическое'),
    Поле ('пол', требуется = IS_IN_SET (['Мужской', 'Женский', 'Другой'])),
    Поле ('профиль', 'текст'),
    Поле ('изображение', 'загрузить'))
 

В этом случае SQLFORM (db.person) создает форму, показанную ниже:

Конструктор SQLFORM позволяет выполнять различные настройки, такие как отображение только подмножества полей, изменение меток, добавление значений к необязательный третий столбец или создание форм UPDATE и DELETE, в отличие от форм INSERT, подобных текущей. SQLFORM - самый крупный объект для экономии времени в web2py.

Класс SQLFORM определен в "gluon / sqlhtml.py". Его можно легко расширить, переопределив его метод xml , метод, который сериализует объекты, для изменения его вывода.

полей

меток

 SQLFORM (table, record = None,
        deletable = False, linkto = None,
        upload = None, fields = None, labels = None,
        col3 = {}, submit_button = 'Отправить',
        delete_label = 'Отметить для удаления',
        showid = True, readonly = False,
        комментарии = Верно, keepopts = [],
        ignore_rw = False, record_id = None,
        formstyle = 'table3cols',
        кнопки = ['отправить'], разделитель = ':',
        extra_fields = Нет,
        ** атрибуты)
 

• Необязательный второй аргумент превращает форму INSERT в форму UPDATE для указанной записи (см. Следующий подраздел).

  showid

  delete_label

  id_label

  submit_button

• Если для deletable задано значение True , в форме UPDATE отображается флажок «Отметить для удаления». Значение метки для этого поля устанавливается с помощью аргумента delete_label .
• submit_button устанавливает значение кнопки отправки.
• id_label устанавливает метку записи «id»
• «id» записи не отображается, если для showid установлено значение Ложь .
• полей - это необязательный список имен полей, которые вы хотите отобразить. Если список предоставлен, отображаются только поля в списке. Например:

• меток - словарь меток полей. Ключ словаря - это имя поля, а соответствующее значение отображается как его метка. Если метка не указана, web2py выводит метку из имени поля (имя поля пишется с заглавной буквы и символы подчеркивания заменяются пробелами). Например:

 label = {'name': 'Ваше полное имя:'}
 

• col3 - словарь значений для третьего столбца.Например:

 col3 = {'name': A ('что это?',
      _href = 'http: //www.google.com/search? q = define: name')}
 

• linkto и upload - это необязательные URL-адреса для пользовательских контроллеров, которые позволяют форме иметь дело со ссылочными полями. Это обсуждается более подробно позже в разделах Ссылки на ссылки на записи и разделы SQLFORM и загрузки соответственно.
• только чтение . Если установлено значение True, форма отображается только для чтения
• комментариев .Если установлено значение False, комментарии col3 не отображаются.
• ignore_rw . Обычно для формы создания / обновления отображаются только поля, помеченные как Writable = True, а для форм только для чтения отображаются только поля, отмеченные как readable = True. При установке ignore_rw = True эти ограничения игнорируются, и отображаются все поля. Это в основном используется в интерфейсе appadmin для отображения всех полей для каждой таблицы, переопределяя то, что указывает модель.

• formstyle

  formstyle определяет стиль, который будет использоваться при сериализации формы в html.Значение по умолчанию берется из response.formstyle , в настоящее время это "bootstrap4_inline". Другие варианты: bootstrap4_stacked, bootstrap3_inline, bootstrap3_stacked, bootstrap2, table3cols, table2cols (одна строка для метки и комментария и одна строка для ввода), ul (создает неупорядоченный список ввода fields), divs (представляет форму с использованием удобных для css div для произвольной настройки), bootstrap, который использует класс формы bootstrap 2.3, form-horizontal. formstyle также может быть функцией, которая генерирует все внутри FORM тег.Вы передаете функции конструктора формы два аргумента, форму и поля. Подсказки можно найти в файле исходного кода sqlhtml.py (ищите функции с именем formstyle_)

• кнопок

  кнопок - это список INPUT s или BUTTON s (хотя технически может быть любая комбинация помощников) который будет добавлен в DIV, где будет находиться кнопка отправки.

Например, добавление кнопки возврата на основе URL (для многостраничной формы) и переименованной кнопки отправки:

 buttons = [BUTTON ('Back', _type = "button", _onClick = "parent. location = '% s' "% URL (...),
           BUTTON ('Далее', _type = "submit")]
 

или кнопка, которая ведет на другую страницу:

 buttons = [..., A («Перейти на другую страницу», _class = 'btn', _href = URL («по умолчанию», «другая страница»))]
 

• разделитель

  разделитель устанавливает строку, которая отделяет метки формы от полей ввода формы, если установлено значение Нет, значение по умолчанию берется из ответа . Form_label_separator

• extra_fields

  extra_fields - это список дополнительных полей с доп.
• Необязательные атрибуты - это аргументы, начинающиеся с подчеркивания, которые вы хотите передать тегу FORM , который отображает объект SQLFORM . Примеры:

 _action = '.'
_method = 'POST'
 

Есть специальный скрытый атрибут . Когда словарь передается как , скрытый , его элементы переводятся в «скрытые» поля INPUT (см. Пример для помощника FORM в главе 5).

 форма = SQLFORM (..., скрыто = ...)
 

вызывает передачу скрытых полей при отправке, не больше и не меньше. form.accepts (...) не предназначен для чтения полученных скрытых полей и перемещения их в form.vars. Причина в безопасности. Скрытые поля могут быть изменены. Поэтому вам нужно явно переместить скрытые поля из запроса в форму:

 form = SQLFORM (..., hidden = dict (a = 'b'))
form.vars.a = request.vars.a
 

Процесс метод

SQLFORM наследует метод процесса из FORM .

SQLFORM и вставить / обновление / удалить

SQLFORM создает новую запись базы данных, когда форма принимается. Если предположить, что

удалить запись

Если вы передаете запись в качестве необязательного второго аргумента конструктору SQLFORM , форма становится формой ОБНОВЛЕНИЯ для этой записи. Это означает, что при отправке формы существующая запись обновляется, а новая запись не вставляется.Если вы установите аргумент deletable = True , в форме ОБНОВЛЕНИЕ отобразится флажок «Проверить для удаления». Если отмечено, запись удаляется.

Если форма отправлена ​​и установлен флажок удаления, для атрибута form.deleted устанавливается значение Истинно .

Вы можете изменить контроллер из предыдущего примера так, чтобы при передаче дополнительного целочисленного аргумента в пути URL-адреса, например:

 / test / default / display_form / 2
 

, и если есть запись с соответствующим идентификатором, SQLFORM генерирует форму UPDATE / DELETE для записи:

 def display_form ():
   запись = db.person (request.args (0)) или перенаправить (URL ('index'))
   form = SQLFORM (db.person, запись)
   если form.process (). принято:
       response.flash = 'форма принята'
   elif form. errors:
       response.flash = 'в форме есть ошибки'
   return dict (form = form)
 

Строка 2 находит запись, а строка 3 создает форму UPDATE / DELETE. Строка 4 выполняет всю соответствующую обработку формы.

Форма обновления очень похожа на форму создания, за исключением того, что она предварительно заполняется текущей записью и предварительно просматривает изображения.По умолчанию deletable = True , что означает, что в форме обновления будет отображаться опция «удалить запись».

Формы редактирования также содержат скрытое поле INPUT с name = "id" , которое используется для идентификации записи. Этот идентификатор также сохраняется на стороне сервера для дополнительной безопасности, и, если посетитель изменяет значение этого поля, ОБНОВЛЕНИЕ не выполняется и web2py вызывает SyntaxError, "пользователь вмешивается в форму".

Когда поле помечено как Writable = False , поле не отображается в формах создания, а отображается только для чтения в формах обновления. Если поле помечено как для записи = False и для чтения = False , то поле не отображается вообще, даже в формах обновления.

Формы, созданные с помощью

 form = SQLFORM (..., ignore_rw = True)
 

игнорирует атрибуты для чтения и для записи и всегда показывает все поля. Формы в appadmin игнорируют их по умолчанию.

Формы, созданные с помощью

 form = SQLFORM (table, record_id, readonly = True)
 

всегда показывает все поля в режиме только для чтения, и они не могут быть приняты.

Пометка поля как Writable = False предотвращает то, что поле является частью формы, и заставляет обработку формы игнорировать значение request.vars.field при обработке формы. Однако, если вы присвоите значение form.vars.field , это значение будет частью вставки или обновления при обработке формы. Это позволяет вам изменять значения полей, которые по какой-то причине вы не хотите включать в форму.

SQLFORM в HTML

Бывают случаи, когда вы хотите использовать SQLFORM , чтобы извлечь выгоду из его создания и обработки формы, но вам нужен уровень настройки формы в HTML, который вы не можете достичь с помощью параметров SQLFORM , поэтому вам нужно создать форму с использованием HTML.

Теперь отредактируйте предыдущий контроллер и добавьте новое действие:

 def display_manual_form ():
    form = SQLFORM (db.person)
    если form.process (session = None, formname = 'test'). принято:
        response.flash = 'форма принята'
    elif form.errors:
        response.flash = 'в форме есть ошибки'
    еще:
        response.flash = 'заполните форму'
    # Примечание: в представление не передается экземпляр формы
    return dict ()
 

и вставьте форму в связанный файл default / display_manual_form.html "view:

 {{extend 'layout.html'}}


  
 Ваше имя  

  
  

 

Обратите внимание, что действие не возвращает форму, потому что ему не нужно передавать ее в представление. Представление содержит форму, созданную вручную в HTML. Форма содержит скрытое поле «_formname», которое должно быть тем же имя формы , указанное в качестве аргумента , принимает в действии.web2py использует имя формы в случае, если на одной странице есть несколько форм, чтобы определить, какая из них была отправлена. Если страница содержит одну форму, вы можете установить formname = None и опустить скрытое поле в представлении.

form.accepts будет искать внутри response.vars данные, соответствующие полям в таблице базы данных db.person . Эти поля объявлены в HTML в формате

Примечание: HTML-форма использует протокол POST (т.е.е. переменные формы не будут передаваться в URL) и тип кодировки multipart / form-data . Последний нужен для работы полей загрузки.

SQLFORM и загрузки

Поля типа «загрузка» являются специальными. Они отображаются как поля INPUT типа type = "file" . Если не указано иное, загруженный файл передается в поток с использованием буфера и сохраняется в папке «uploads» приложения под новым безопасным именем, назначаемым автоматически. Затем имя этого файла сохраняется в поле типа «загрузить».

В качестве примера рассмотрим следующую модель:

 db.define_table ('person',
    Поле ('имя', требуется = IS_NOT_EMPTY ()),
    Поле ('изображение', 'загрузить'))
 

Вы можете использовать то же действие контроллера "display_form", показанное выше.

Когда вы вставляете новую запись, форма позволяет вам искать файл. Выберите, например, изображение в формате jpg. Файл загружен и сохранен как:

 application / test / uploads / person.image.XXXXX.jpg
 

«XXXXXX» - это случайный идентификатор файла, присвоенный web2py.

content-disposition

Обратите внимание, что по умолчанию исходное имя загружаемого файла закодировано в b16 и используется для создания нового имени файла. Это имя извлекается действием по умолчанию «загрузка» и используется для установки заголовка размещения содержимого на исходное имя файла.

Сохранилось только его расширение. Это требование безопасности, поскольку имя файла может содержать специальные символы, которые могут позволить посетителю выполнять атаки обхода каталога или другие вредоносные операции.

Новое имя файла также сохраняется в form.vars.image .

При редактировании записи с помощью формы UPDATE было бы неплохо отобразить ссылку на существующий загруженный файл, и web2py предоставляет способ сделать это.

Если вы передаете URL-адрес конструктору SQLFORM через аргумент upload , web2py использует действие по этому URL-адресу для загрузки файла. Рассмотрим следующие действия:

 def display_form ():
   record = db.person (запрос.аргументы (0))
   form = SQLFORM (db.person, record, deletable = True,
                  upload = URL ('скачать'))
   если form. process (). принято:
       response.flash = 'форма принята'
   elif form.errors:
       response.flash = 'в форме есть ошибки'
   return dict (form = form)

def скачать ():
    вернуть response.download (запрос, db)
 

Теперь вставьте новую запись по URL:

 http://127.0.0.1:8000/test/default/display_form
 

Загрузите изображение, отправьте форму, а затем отредактируйте вновь созданную запись, посетив:

 http: // 127.0.0.1: 8000 / тест / по умолчанию / display_form / 3
 

(здесь мы предполагаем, что последняя запись имеет id = 3). Форма будет отображать предварительный просмотр изображения, как показано ниже:

Эта форма после сериализации создает следующий HTML-код:

   Изображение:  
 
  [ файл  |
 удалить] 
    
   Установите флажок для удаления:     
 

, который содержит ссылку, разрешающую загрузку загруженного файла, и флажок для удаления файла из записи базы данных, таким образом сохраняя NULL в поле «изображение».

Почему этот механизм обнажен? Зачем нужно писать функцию загрузки? Потому что вы можете захотеть задействовать некоторый механизм авторизации в функции загрузки. См. Пример в главе 9.

Обычно загруженные файлы хранятся в «app / uploads», но вы можете указать альтернативное расположение:

  Поле ('image', 'upload', uploadfolder = '...')  

В большинстве операционных систем доступ к файловой системе может стать медленным, если в одной папке много файлов.Если вы планируете загрузить более 1000 файлов, вы можете попросить web2py организовать загрузки в подпапки:

  Поле ('image', 'upload', uploadseparate = True)  

Сохранение исходного имени файла

web2py автоматически сохраняет исходное имя файла внутри нового имени файла UUID и извлекает его при загрузке файла. После загрузки исходное имя файла сохраняется в заголовке Content-Disposition ответа HTTP. Все это делается прозрачно, без программирования.

Иногда вам может понадобиться сохранить исходное имя файла в поле базы данных.