Guide: printing web maps with subtype group layers in 11.5

StijnSchouten

Hi fellow enterprise users,

I'm not sure if there is interest in this information but we had some problems printing web maps that contained subtype group layers. Officially these layers are not supported for printing in versions 11.5 and below. However, there is a workaround I wanted to share.

It involves setting up a custom print tool and setting the token on subtype layer as well. In the 11.5 version of the webmap there is no dictionary entry of a token anywhere. Adding this token makes sure the print tool can access the subtype layer.

Some code snippets:

        dict_web_map = json.loads(self.web_map_as_json)

        for layer in dict_web_map.get("operationalLayers", []):
            if "token" in layer:
                layer["token"] = self.token
            if layer.get("layerType") == "SubtypeGroupLayer":
                for sublayer in layer.get("layers", []):
                    sublayer["token"] = self.token

        for table in dict_web_map.get("tables", []):
            if "token" in table:
                table["token"] = self.token

        self.web_map_as_json = json.dumps(dict_web_map)

 

        result = arcpy.server.ExportWebMap(Web_Map_as_JSON=self.web_map_as_json,
                                           Format=self.format_param,
                                           Layout_Template=self.layout_template,
                                           Layout_Item_ID=self.layout_item_id)
        return result.getOutput(0)

 

I can make a more complete guide if there is interest

StijnSchouten

@AH2 & @AniketDhaygude007 here is the full toolbox that is published as a geoprocessing service

After publishing this toolbox you can, within experience builder, create a print widget and select this service as the printing service. 

# -*- coding: utf-8 -*-
import json
import arcgis
import arcpy
import sys
import traceback
import os

class Toolbox:
    def __init__(self):
        """Define the toolbox (the name of the toolbox is the name of the
        .pyt file)."""
        self.label = "WebmapPrint"
        self.alias = "webmapprint"

        # List of tool classes associated with this toolbox
        self.tools = [WebmapPrint]


class WebmapPrint:
    def __init__(self):
        """Define the tool (tool name is the name of the class)."""
        self.label = "WebmapPrint"

    def getParameterInfo(self):
        """Define the tool parameters."""
        in_map = arcpy.Parameter(
            name="Web_Map_as_JSON",
            displayName="Web_Map_as_JSON",
            datatype="GPString",
            parameterType="Required",
            direction="Input"
        )
        # in_map.value = "#"
        in_format = arcpy.Parameter(
            name="Format",
            displayName="Format",
            datatype="GPString",
            parameterType="Optional",
            direction="Input",
        )
        in_layout = arcpy.Parameter(
            name="Layout_Template",
            displayName="Layout_Template",
            datatype="GPString",
            parameterType="Optional",
            direction="Input",
        )
        in_layout_item = arcpy.Parameter(
            name="Layout_Item_ID",
            displayName="Layout_Item_ID",
            datatype="GPString",
            parameterType="Optional",
            direction="Input",
        )
        out_file = arcpy.Parameter(
            name="Output_File",
            displayName="Output_File",
            datatype="DEFile",
            parameterType="Derived",
            direction="Output",
        )
        in_format.filter.type = "ValueList"
        in_format.filter.list = [ 'PDF', 'PNG32', 'PNG8', 'JPG', 'GIF', 'EPS', 'SVG', 'SVGZ', 'AIX', 'TIFF' ]
        in_format.value = 'PDF'

        in_layout.filter.type = "ValueList"
        in_layout.filter.list = [ 'A3 Landscape', 'A3 Portrait', 'A4 Landscape', 'A4 Portrait', 'Letter ANSI A Landscape', 
                                 'Letter ANSI A Portrait', 'Tabloid ANSI B Landscape', 'Tabloid ANSI B Portrait', 'MAP_ONLY' ]
        in_layout.value = 'MAP_ONLY'

        params = [in_map, in_format, in_layout, out_file, in_layout_item]
        return params

    def isLicensed(self):
        """Set whether the tool is licensed to execute."""
        return True

    def updateParameters(self, parameters):
        """Modify the values and properties of parameters before internal
        validation is performed.  This method is called whenever a parameter
        has been changed."""
        return

    def updateMessages(self, parameters):
        """Modify the messages created by internal validation for each tool
        parameter. This method is called after internal validation."""
        return

    def execute(self, parameters, messages):
        """The source code of the tool."""
        arcpy.env.overwriteOutput = True
        web_map_as_json = parameters[0].valueAsText
        format_param = parameters[1].valueAsText
        layout_template = parameters[2].valueAsText
        layout_item_id = parameters[4].valueAsText

        arcpy.AddMessage(f"All parameters received: Web_Map_as_JSON length: {len(web_map_as_json)}, Format: {format_param}, Layout_Template: {layout_template}")

        if web_map_as_json is None or web_map_as_json.strip() == "" or web_map_as_json == "##":
            arcpy.AddMessage("Test run detected. No Web Map JSON provided.")
            return

        etc = ExportWebMap(web_map_as_json, format_param, layout_template, layout_item_id)
        try:
            result = etc.runner()
            arcpy.AddMessage(f"Output file path: {result}")
            arcpy.SetParameterAsText(3, result)
        except Exception as e:
            tb = sys.exc_info()[2]
            tbinfo = traceback.format_tb(tb)[0]

            # Concatenate information together concerning the error into a message string
            pymsg = "PYTHON ERRORS:\nTraceback info:\n" + tbinfo + "\nError Info:\n" + str(sys.exc_info()[1])
            msgs = "ArcPy MESSAGES:\n" + arcpy.GetMessages() + "\n"
            arcpy.AddWarning(f"An error occurred during execution: {e}")
            arcpy.AddWarning(pymsg)
            arcpy.AddWarning(msgs)
            result = etc.create_txt_file(f"Err_Fout_bij_uitvoeren_tool", 
                                         lines=[str(e), pymsg, msgs, 'INPUT_VARIABLES', web_map_as_json, format_param, layout_template])
            arcpy.SetParameterAsText(3, result)
        return

    def postExecute(self, parameters):
        """This method takes place after outputs are processed and
        added to the display."""
        return


class ExportWebMap:
    """Class containing all code for converting feature layers to CAD files"""
    def __init__(
        self,
        web_map_as_json: str,
        format_param: str,
        layout_template: str,
        layout_item_id: str
    ):
        self.web_map_as_json = web_map_as_json
        self.format_param = format_param
        self.layout_template = layout_template
        self.layout_item_id = layout_item_id

    @staticmethod
    def create_txt_file(output_path: str, lines=None) -> None:
        """Create a text file with the given content at the specified path"""
        try:
            write_path = os.path.join(arcpy.env.scratchFolder, output_path + '.txt')
            with open(write_path, 'w', encoding='utf-8') as f:
                f.write("er is een fout opgetreden")
                f.write("\n")
                f.write(output_path)
                if lines:
                    for line in lines:
                        f.write("\n")
                        f.write(str(line))
            arcpy.AddMessage(f"Text file created at {output_path}")
            return write_path
        except Exception as e:
            arcpy.AddError(f"Failed to create text file at {output_path} due to {e}")
            raise e
        
    def get_token_from_layer(self):
        dict_web_map = json.loads(self.web_map_as_json)
        for layer in dict_web_map.get("operationalLayers", []):
            if "token" in layer:
                self.token = layer["token"]
                arcpy.AddMessage("Token obtained from web map JSON.")
                return
        raise ValueError("No token found in web map JSON.")

    def change_token_in_json(self):
        """Replace tokens in web map json and inject tokens into SubtypeGroupLayer sublayers"""
        dict_web_map = json.loads(self.web_map_as_json)

        for layer in dict_web_map.get("operationalLayers", []):
            if "token" in layer:
                layer["token"] = self.token
            if layer.get("layerType") == "SubtypeGroupLayer":
                for sublayer in layer.get("layers", []):
                    sublayer["token"] = self.token

        for table in dict_web_map.get("tables", []):
            if "token" in table:
                table["token"] = self.token

        self.web_map_as_json = json.dumps(dict_web_map)
        return
    
    def print_map(self):
        result = arcpy.server.ExportWebMap(Web_Map_as_JSON=self.web_map_as_json,
                                           Format=self.format_param,
                                           Layout_Template=self.layout_template,
                                           Layout_Item_ID=self.layout_item_id)
        return result.getOutput(0)
                                           
                                           
    def runner(
        self
    ) -> str:
        """Orchestation method for chaining methods together"""
        self.get_token_from_layer()
        self.change_token_in_json()
        arcpy.AddMessage("Changed tokens in web map JSON.")
        output_file = self.print_map()
        arcpy.AddMessage(f"Map printed successfully. Output file: {output_file}")
       
        return output_file