1 #

     2 # Copyright (c) 2008-2015 Thierry Florac <tflorac AT ulthar.net>

     3 # All Rights Reserved.

     4 #

     5 # This software is subject to the provisions of the Zope Public License,

     6 # Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.

     7 # THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED

     8 # WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

     9 # WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS

    10 # FOR A PARTICULAR PURPOSE.

    11 #

    12 

    13 __docformat__ = 'restructuredtext'

    14 

    15 

    16 # import standard library

    17 

    18 # import interfaces

    19 from pyams_form.form import AJAXAddForm, AJAXEditForm

    20 from pyams_gis.interfaces.layer import ITileMapLayer, IWMSMapLayer, IGeoportalMapLayer, IEsriFeatureMapLayer, \

    21     IGoogleMapLayer

    22 from pyams_gis.interfaces.utility import IMapManager

    23 from pyams_gis.layer import TileMapLayer, WMSMapLayer, GeoportalMapLayer, EsriFeatureMapLayer, GoogleMapLayer

    24 from pyams_gis.zmi.interfaces import ILayerAddForm

    25 from pyams_i18n.interfaces import II18n

    26 from pyams_skin.interfaces.viewlet import IToolbarAddingMenu

    27 from pyams_skin.layer import IPyAMSLayer

    28 from pyams_utils.interfaces import MANAGE_SYSTEM_PERMISSION, VIEW_SYSTEM_PERMISSION

    29 from pyams_zmi.layer import IAdminLayer

    30 from z3c.form.interfaces import IDataExtractedEvent, DISPLAY_MODE

    31 from zope.component.interfaces import ISite

    32 

    33 # import packages

    34 from pyams_gis.zmi.utility import MapManagerLayersTable

    35 from pyams_pagelet.pagelet import pagelet_config

    36 from pyams_skin.viewlet.toolbar import ToolbarMenuItem

    37 from pyams_utils.registry import query_utility

    38 from pyams_utils.url import absolute_url

    39 from pyams_viewlet.viewlet import viewlet_config

    40 from pyams_zmi.form import AdminDialogAddForm, AdminDialogEditForm

    41 from pyramid.events import subscriber

    42 from pyramid.view import view_config

    43 from z3c.form import field

    44 from zope.interface import implementer, Invalid

    45 

    46 from pyams_gis import _

    47 

    48 

    49 @subscriber(IDataExtractedEvent, form_selector=ILayerAddForm)

    50 def handle_new_geoportal_layer_data(event):

    51     """Handle new layer data extraction"""

    52     manager = query_utility(IMapManager)

    53     name = event.data.get('name')

    54     if name in manager:

    55         event.form.widgets.errors += (Invalid(_("Specified layer name already exists!")))

    56 

    57 

    58 #

    59 # Base tiles layer forms

    60 #

    61 

    62 @viewlet_config(name='add-tile-layer.menu', context=ISite, layer=IAdminLayer,

    63                 view=MapManagerLayersTable, manager=IToolbarAddingMenu,

    64                 permission=MANAGE_SYSTEM_PERMISSION, weight=10)

    65 class TileLayerAddMenu(ToolbarMenuItem):

    66     """Tile layer add menu"""

    67 

    68     label = _("Add tile layer...")

    69     label_css_class = 'fa fa-fw fa-globe'

    70     url = 'add-tile-layer.html'

    71     modal_target = True

    72 

    73 

    74 @pagelet_config(name='add-tile-layer.html', context=ISite, layer=IPyAMSLayer,

    75                 permission=MANAGE_SYSTEM_PERMISSION)

    76 @implementer(ILayerAddForm)

    77 class TileLayerAddForm(AdminDialogAddForm):

    78     """Tile layer add form"""

    79 

    80     title = _("Maps manager")

    81     legend = _("Add tile layer")

    82     icon_css_class = 'fa fa-fw fa-globe'

    83     dialog_class = 'modal-large'

    84 

    85     fields = field.Fields(ITileMapLayer).omit('__name__', '__parent__')

    86     ajax_handler = 'add-tile-layer.json'

    87     edit_permission = MANAGE_SYSTEM_PERMISSION

    88 

    89     def create(self, data):

    90         return TileMapLayer()

    91 

    92     def add(self, layer):

    93         context = query_utility(IMapManager)

    94         context[layer.name] = layer

    95 

    96     def nextURL(self):

    97         return absolute_url(self.context, self.request, 'map-manager.html')

    98 

    99 

   100 @view_config(name='add-tile-layer.json', context=ISite, request_type=IPyAMSLayer,

   101              permission=MANAGE_SYSTEM_PERMISSION, renderer='json', xhr=True)

   102 class TileLayerAJAXAddForm(AJAXAddForm, TileLayerAddForm):

   103     """Tile layer add form, JSON renderer"""

   104 

   105 

   106 @pagelet_config(name='properties.html', context=ITileMapLayer, layer=IPyAMSLayer,

   107                 permission=VIEW_SYSTEM_PERMISSION)

   108 class TileLayerEditForm(AdminDialogEditForm):

   109     """Tile layer edit form"""

   110 

   111     @property

   112     def title(self):

   113         return II18n(self.context).query_attribute('title', request=self.request)

   114 

   115     legend = _("Edit layer properties")

   116     icon_css_class = 'fa fa-fw fa-globe'

   117     dialog_class = 'modal-large'

   118 

   119     fields = field.Fields(ITileMapLayer).omit('__name__', '__parent__')

   120     ajax_handler = 'properties.json'

   121     edit_permission = MANAGE_SYSTEM_PERMISSION

   122 

   123     def updateWidgets(self, prefix=None):

   124         super(TileLayerEditForm, self).updateWidgets(prefix)

   125         if 'name' in self.widgets:

   126             self.widgets['name'].mode = DISPLAY_MODE

   127 

   128 

   129 @view_config(name='properties.json', context=ITileMapLayer, request_type=IPyAMSLayer,

   130              permission=MANAGE_SYSTEM_PERMISSION, renderer='json', xhr=True)

   131 class TileLayerAJAXEditForm(AJAXEditForm, TileLayerEditForm):

   132     """Tile layer edit form, JSON renderer"""

   133 

   134 

   135 #

   136 # WMS layer forms

   137 #

   138 

   139 @viewlet_config(name='add-wms-layer.menu', context=ISite, layer=IAdminLayer,

   140                 view=MapManagerLayersTable, manager=IToolbarAddingMenu,

   141                 permission=MANAGE_SYSTEM_PERMISSION, weight=20)

   142 class WMSLayerAddMenu(ToolbarMenuItem):

   143     """WMS layer add menu"""

   144 

   145     label = _("Add WMS layer...")

   146     label_css_class = 'fa fa-fw fa-map'

   147     url = 'add-wms-layer.html'

   148     modal_target = True

   149 

   150 

   151 @pagelet_config(name='add-wms-layer.html', context=ISite, layer=IPyAMSLayer,

   152                 permission=MANAGE_SYSTEM_PERMISSION)

   153 @implementer(ILayerAddForm)

   154 class WMSLayerAddForm(AdminDialogAddForm):

   155     """WMS layer add form"""

   156 

   157     title = _("Maps manager")

   158     legend = _("Add WMS layer")

   159     icon_css_class = 'fa fa-fw fa-map'

   160     dialog_class = 'modal-large'

   161 

   162     fields = field.Fields(IWMSMapLayer).omit('__name__', '__parent__')

   163     ajax_handler = 'add-wms-layer.json'

   164     edit_permission = MANAGE_SYSTEM_PERMISSION

   165 

   166     def create(self, data):

   167         return WMSMapLayer()

   168 

   169     def add(self, layer):

   170         context = query_utility(IMapManager)

   171         context[layer.name] = layer

   172 

   173     def nextURL(self):

   174         return absolute_url(self.context, self.request, 'map-manager.html')

   175 

   176 

   177 @view_config(name='add-wms-layer.json', context=ISite, request_type=IPyAMSLayer,

   178              permission=MANAGE_SYSTEM_PERMISSION, renderer='json', xhr=True)

   179 class WMSLayerAJAXAddForm(AJAXAddForm, WMSLayerAddForm):

   180     """WMS layer add form, JSON renderer"""

   181 

   182 

   183 @pagelet_config(name='properties.html', context=IWMSMapLayer, layer=IPyAMSLayer,

   184                 permission=VIEW_SYSTEM_PERMISSION)

   185 class WMSLayerEditForm(AdminDialogEditForm):

   186     """WMS layer edit form"""

   187 

   188     @property

   189     def title(self):

   190         return II18n(self.context).query_attribute('title', request=self.request)

   191 

   192     legend = _("Edit layer properties")

   193     icon_css_class = 'fa fa-fw fa-map'

   194     dialog_class = 'modal-large'

   195 

   196     fields = field.Fields(IWMSMapLayer).omit('__name__', '__parent__')

   197     ajax_handler = 'properties.json'

   198     edit_permission = MANAGE_SYSTEM_PERMISSION

   199 

   200     def updateWidgets(self, prefix=None):

   201         super(WMSLayerEditForm, self).updateWidgets(prefix)

   202         if 'name' in self.widgets:

   203             self.widgets['name'].mode = DISPLAY_MODE

   204 

   205 

   206 @view_config(name='properties.json', context=IWMSMapLayer, request_type=IPyAMSLayer,

   207              permission=MANAGE_SYSTEM_PERMISSION, renderer='json', xhr=True)

   208 class WMSLayerAJAXEditForm(AJAXEditForm, WMSLayerEditForm):

   209     """WMS layer edit form, JSON renderer"""

   210 

   211 

   212 #

   213 # Geoportal layer forms

   214 #

   215 

   216 @viewlet_config(name='add-geoportal-layer.menu', context=ISite, layer=IAdminLayer,

   217                 view=MapManagerLayersTable, manager=IToolbarAddingMenu,

   218                 permission=MANAGE_SYSTEM_PERMISSION, weight=50)

   219 class GeoportalLayerAddMenu(ToolbarMenuItem):

   220     """Geoportal layer add menu"""

   221 

   222     label = _("Add Geoportal WMS layer...")

   223     label_css_class = 'fa fa-fw fa-map-o'

   224     url = 'add-geoportal-layer.html'

   225     modal_target = True

   226 

   227 

   228 @pagelet_config(name='add-geoportal-layer.html', context=ISite, layer=IPyAMSLayer,

   229                 permission=MANAGE_SYSTEM_PERMISSION)

   230 @implementer(ILayerAddForm)

   231 class GeoportalLayerAddForm(AdminDialogAddForm):

   232     """Geoportal layer add form"""

   233 

   234     title = _("Maps manager")

   235     legend = _("Add IGN Geoportal layer")

   236     icon_css_class = 'fa fa-fw fa-map-o'

   237     dialog_class = 'modal-large'

   238 

   239     fields = field.Fields(IGeoportalMapLayer).omit('__name__', '__parent__')

   240     ajax_handler = 'add-geoportal-layer.json'

   241     edit_permission = MANAGE_SYSTEM_PERMISSION

   242 

   243     def create(self, data):

   244         return GeoportalMapLayer()

   245 

   246     def add(self, layer):

   247         context = query_utility(IMapManager)

   248         context[layer.name] = layer

   249 

   250     def nextURL(self):

   251         return absolute_url(self.context, self.request, 'map-manager.html')

   252 

   253 

   254 @view_config(name='add-geoportal-layer.json', context=ISite, request_type=IPyAMSLayer,

   255              permission=MANAGE_SYSTEM_PERMISSION, renderer='json', xhr=True)

   256 class GeoportalLayerAJAXAddForm(AJAXAddForm, GeoportalLayerAddForm):

   257     """Geoportal layer add form, JSON renderer"""

   258 

   259 

   260 @pagelet_config(name='properties.html', context=IGeoportalMapLayer, layer=IPyAMSLayer,

   261                 permission=VIEW_SYSTEM_PERMISSION)

   262 class GeoportalLayerEditForm(AdminDialogEditForm):

   263     """Geoportal layer edit form"""

   264 

   265     @property

   266     def title(self):

   267         return II18n(self.context).query_attribute('title', request=self.request)

   268 

   269     legend = _("Edit layer properties")

   270     icon_css_class = 'fa fa-fw fa-map-o'

   271     dialog_class = 'modal-large'

   272 

   273     fields = field.Fields(IGeoportalMapLayer).omit('__name__', '__parent__')

   274     ajax_handler = 'properties.json'

   275     edit_permission = MANAGE_SYSTEM_PERMISSION

   276 

   277     def updateWidgets(self, prefix=None):

   278         super(GeoportalLayerEditForm, self).updateWidgets(prefix)

   279         if 'name' in self.widgets:

   280             self.widgets['name'].mode = DISPLAY_MODE

   281 

   282 

   283 @view_config(name='properties.json', context=IGeoportalMapLayer, request_type=IPyAMSLayer,

   284              permission=MANAGE_SYSTEM_PERMISSION, renderer='json', xhr=True)

   285 class GeoportalLayerAJAXEditForm(AJAXEditForm, GeoportalLayerEditForm):

   286     """Geoportal layer edit form, JSON renderer"""

   287 

   288 

   289 #

   290 # ESRI feature layer forms

   291 #

   292 

   293 @viewlet_config(name='add-esri-feature-layer.menu', context=ISite, layer=IAdminLayer,

   294                 view=MapManagerLayersTable, manager=IToolbarAddingMenu,

   295                 permission=MANAGE_SYSTEM_PERMISSION, weight=70)

   296 class EsriFeatureLayerAddMenu(ToolbarMenuItem):

   297     """ESRI feature layer add menu"""

   298 

   299     label = _("Add ESRI feature layer...")

   300     label_css_class = 'fa fa-fw fa-map-signs'

   301     url = 'add-esri-feature-layer.html'

   302     modal_target = True

   303 

   304 

   305 @pagelet_config(name='add-esri-feature-layer.html', context=ISite, layer=IPyAMSLayer,

   306                 permission=MANAGE_SYSTEM_PERMISSION)

   307 @implementer(ILayerAddForm)

   308 class EsriFeatureLayerAddForm(AdminDialogAddForm):

   309     """ESRI feature layer add form"""

   310 

   311     title = _("Maps manager")

   312     legend = _("Add ESRI feature layer")

   313     icon_css_class = 'fa fa-fw fa-map-signs'

   314     dialog_class = 'modal-large'

   315 

   316     fields = field.Fields(IEsriFeatureMapLayer).omit('__name__', '__parent__')

   317     ajax_handler = 'add-esri-feature-layer.json'

   318     edit_permission = MANAGE_SYSTEM_PERMISSION

   319 

   320     def create(self, data):

   321         return EsriFeatureMapLayer()

   322 

   323     def add(self, layer):

   324         context = query_utility(IMapManager)

   325         context[layer.name] = layer

   326 

   327     def nextURL(self):

   328         return absolute_url(self.context, self.request, 'map-manager.html')

   329 

   330 

   331 @view_config(name='add-esri-feature-layer.json', context=ISite, request_type=IPyAMSLayer,

   332              permission=MANAGE_SYSTEM_PERMISSION, renderer='json', xhr=True)

   333 class EsriFeatureLayerAJAXAddForm(AJAXAddForm, EsriFeatureLayerAddForm):

   334     """ESRI feature layer add form, JSON renderer"""

   335 

   336 

   337 @pagelet_config(name='properties.html', context=IEsriFeatureMapLayer, layer=IPyAMSLayer,

   338                 permission=VIEW_SYSTEM_PERMISSION)

   339 class EsriFeatureLayerEditForm(AdminDialogEditForm):

   340     """ESRI feature layer edit form"""

   341 

   342     @property

   343     def title(self):

   344         return II18n(self.context).query_attribute('title', request=self.request)

   345 

   346     legend = _("Edit layer properties")

   347     icon_css_class = 'fa fa-fw fa-map-signs'

   348     dialog_class = 'modal-large'

   349 

   350     fields = field.Fields(IEsriFeatureMapLayer).omit('__name__', '__parent__')

   351     ajax_handler = 'properties.json'

   352     edit_permission = MANAGE_SYSTEM_PERMISSION

   353 

   354     def updateWidgets(self, prefix=None):

   355         super(EsriFeatureLayerEditForm, self).updateWidgets(prefix)

   356         if 'name' in self.widgets:

   357             self.widgets['name'].mode = DISPLAY_MODE

   358 

   359 

   360 @view_config(name='properties.json', context=IEsriFeatureMapLayer, request_type=IPyAMSLayer,

   361              permission=MANAGE_SYSTEM_PERMISSION, renderer='json', xhr=True)

   362 class EsriFeatureLayerAJAXEditForm(AJAXEditForm, EsriFeatureLayerEditForm):

   363     """ESRI feature layer edit form, JSON renderer"""

   364 

   365 

   366 #

   367 # Google maps layer forms

   368 #

   369 

   370 @viewlet_config(name='add-google-layer.menu', context=ISite, layer=IAdminLayer,

   371                 view=MapManagerLayersTable, manager=IToolbarAddingMenu,

   372                 permission=MANAGE_SYSTEM_PERMISSION, weight=80)

   373 class GoogleMapLayerAddMenu(ToolbarMenuItem):

   374     """Google Maps layer add menu"""

   375 

   376     label = _("Add Google Maps layer...")

   377     label_css_class = 'fa fa-fw fa-map-marker'

   378     url = 'add-google-layer.html'

   379     modal_target = True

   380 

   381 

   382 @pagelet_config(name='add-google-layer.html', context=ISite, layer=IPyAMSLayer,

   383                 permission=MANAGE_SYSTEM_PERMISSION)

   384 @implementer(ILayerAddForm)

   385 class GoogleMapLayerAddForm(AdminDialogAddForm):

   386     """Google Maps layer add form"""

   387 

   388     title = _("Maps manager")

   389     legend = _("Add Google Maps layer")

   390     icon_css_class = 'fa fa-fw fa-map-marker'

   391     dialog_class = 'modal-large'

   392 

   393     fields = field.Fields(IGoogleMapLayer).omit('__name__', '__parent__')

   394     ajax_handler = 'add-google-layer.json'

   395     edit_permission = MANAGE_SYSTEM_PERMISSION

   396 

   397     def create(self, data):

   398         return GoogleMapLayer()

   399 

   400     def add(self, layer):

   401         context = query_utility(IMapManager)

   402         context[layer.name] = layer

   403 

   404     def nextURL(self):

   405         return absolute_url(self.context, self.request, 'map-manager.html')

   406 

   407 

   408 @view_config(name='add-google-layer.json', context=ISite, request_type=IPyAMSLayer,

   409              permission=MANAGE_SYSTEM_PERMISSION, renderer='json', xhr=True)

   410 class GoogleMapLayerAJAXAddForm(AJAXAddForm, GoogleMapLayerAddForm):

   411     """Google Maps layer add form, JSON renderer"""

   412 

   413 

   414 @pagelet_config(name='properties.html', context=IGoogleMapLayer, layer=IPyAMSLayer,

   415                 permission=VIEW_SYSTEM_PERMISSION)

   416 class GoogleMapLayerEditForm(AdminDialogEditForm):

   417     """Google Maps layer edit form"""

   418 

   419     @property

   420     def title(self):

   421         return II18n(self.context).query_attribute('title', request=self.request)

   422 

   423     legend = _("Edit layer properties")

   424     icon_css_class = 'fa fa-fw fa-map-marker'

   425     dialog_class = 'modal-large'

   426 

   427     fields = field.Fields(IGoogleMapLayer).omit('__name__', '__parent__')

   428     ajax_handler = 'properties.json'

   429     edit_permission = MANAGE_SYSTEM_PERMISSION

   430 

   431     def updateWidgets(self, prefix=None):

   432         super(GoogleMapLayerEditForm, self).updateWidgets(prefix)

   433         if 'name' in self.widgets:

   434             self.widgets['name'].mode = DISPLAY_MODE

   435 

   436 

   437 @view_config(name='properties.json', context=IGoogleMapLayer, request_type=IPyAMSLayer,

   438              permission=MANAGE_SYSTEM_PERMISSION, renderer='json', xhr=True)

   439 class GoogleMapLayerAJAXEditForm(AJAXEditForm, GoogleMapLayerEditForm):

   440     """Google Maps layer edit form, JSON renderer"""