def processAlgorithm(self, parameters, context, feedback):
        """
        Here is where the processing itself takes place.
        """
        #get the network handler
        layerHandler = LayerHandler()
        networkHandler = NetworkHandler()
        algRunner = AlgRunner()
        self.nodeTypeNameDict = networkHandler.nodeTypeDict
        # get network layer
        networkLayer = self.parameterAsLayer(parameters, self.NETWORK_LAYER, context)
        if networkLayer is None:
            raise QgsProcessingException(self.invalidSourceError(parameters, self.NETWORK_LAYER))
        attributeBlackList = self.parameterAsFields(parameters, self.ATTRIBUTE_BLACK_LIST, context)
        ignoreVirtual = self.parameterAsBool(parameters, self.IGNORE_VIRTUAL_FIELDS, context)
        ignorePK = self.parameterAsBool(parameters, self.IGNORE_PK_FIELDS, context)
        # get network node layer
        (nodeSink, dest_id) = self.parameterAsSink(parameters, self.NETWORK_NODES,
                context, self.getFields(), QgsWkbTypes.MultiPoint, networkLayer.sourceCrs())
        #prepairs flag sink for raising errors
        self.prepareFlagSink(parameters, networkLayer, QgsWkbTypes.MultiPoint, context)
        
        waterBodyClasses = self.parameterAsLayer(parameters, self.WATER_BODY_LAYERS, context)
        waterBodyClasses = waterBodyClasses if waterBodyClasses is not None else []
        # get water sink layer
        waterSinkLayer = self.parameterAsLayer(parameters, self.SINK_LAYER, context)
        # get spillway layer
        spillwayLayer = self.parameterAsLayer(parameters, self.SPILLWAY_LAYER, context)
        # get frame layer
        frameLayer = self.parameterAsLayer(parameters, self.REF_LAYER, context)
        currStep = 0
        if frameLayer is None:
            raise QgsProcessingException(self.invalidSourceError(parameters, self.REF_LAYER))
        multiStepFeedback = QgsProcessingMultiStepFeedback(3, feedback)
        multiStepFeedback.setCurrentStep(currStep)
        multiStepFeedback.pushInfo(self.tr('Preparing bounds...'))
        frame = layerHandler.getFrameOutterBounds(frameLayer, algRunner, context, feedback=multiStepFeedback)
        currStep += 1
        # get search radius
        searchRadius = self.parameterAsDouble(parameters, self.SEARCH_RADIUS, context)
        # get ditch layer
        ditchLayer = self.parameterAsLayer(parameters, self.DITCH_LAYER, context)

        #new step
        multiStepFeedback.setCurrentStep(currStep)
        multiStepFeedback.pushInfo(self.tr('Performing node identification...'))
        self.nodeDict = networkHandler.identifyAllNodes(networkLayer=networkLayer, feedback=multiStepFeedback) #zoado, mudar lógica
        multiStepFeedback.pushInfo(self.tr('{node_count} node(s) identificated...').format(node_count=len(self.nodeDict)))
        currStep += 1
        #new step
        multiStepFeedback.setCurrentStep(currStep)
        multiStepFeedback.pushInfo(self.tr('Performing node classification...'))
        networkHandler.nodeDict = self.nodeDict
        self.nodeTypeDict, nodeFlagDict = networkHandler.classifyAllNodes(
                networkLayer=networkLayer,
                frameLyrContourList=frame,
                waterBodiesLayers=waterBodyClasses,
                searchRadius=searchRadius,
                waterSinkLayer=waterSinkLayer,
                spillwayLayer=spillwayLayer,
                feedback=multiStepFeedback,
                attributeBlackList=attributeBlackList,
                excludePrimaryKeys=ignorePK,
                ignoreVirtualFields=ignoreVirtual,
                ditchLayer=ditchLayer
            )
        currStep += 1
        #new step
        multiStepFeedback.setCurrentStep(currStep)
        multiStepFeedback.pushInfo(self.tr('Writing nodes...'))
        self.fillNodeSink(
            nodeSink=nodeSink,
            networkLineLayerName=networkLayer.name(),
            nodeFlagDict=nodeFlagDict,
            feedback=multiStepFeedback)
        return {self.NETWORK_NODES : dest_id, self.FLAGS : self.flag_id}
    def processAlgorithm(self, parameters, context, feedback):
        """
        Here is where the processing itself takes place.
        """
        #get the network handler
        layerHandler = LayerHandler()
        networkHandler = NetworkHandler()
        algRunner = AlgRunner()
        # get network layer
        networkLayer = self.parameterAsLayer(parameters, self.NETWORK_LAYER,
                                             context)
        if networkLayer is None:
            raise QgsProcessingException(
                self.invalidSourceError(parameters, self.NETWORK_LAYER))
        # get network node layer
        networkNodeLayer = self.parameterAsLayer(parameters, self.NODE_LAYER,
                                                 context)
        if networkLayer is None:
            raise QgsProcessingException(
                self.invalidSourceError(parameters, self.NODE_LAYER))
        waterBodyClasses = self.parameterAsLayer(parameters,
                                                 self.WATER_BODY_LAYERS,
                                                 context)
        networkNodeLayer.startEditing()
        # get water sink layer
        waterSinkLayer = self.parameterAsLayer(parameters, self.SINK_LAYER,
                                               context)
        # get spillway layer
        spillwayLayer = self.parameterAsLayer(parameters, self.SPILLWAY_LAYER,
                                              context)
        # get frame layer
        frameLayer = self.parameterAsLayer(parameters, self.REF_LAYER, context)
        if frameLayer is None:
            raise QgsProcessingException(
                self.invalidSourceError(parameters, self.REF_LAYER))
        # get ditch layer
        ditchLayer = self.parameterAsLayer(parameters, self.DITCH_LAYER,
                                           context)
        attributeBlackList = self.parameterAsFields(parameters,
                                                    self.ATTRIBUTE_BLACK_LIST,
                                                    context)
        ignoreVirtual = self.parameterAsBool(parameters,
                                             self.IGNORE_VIRTUAL_FIELDS,
                                             context)
        ignorePK = self.parameterAsBool(parameters, self.IGNORE_PK_FIELDS,
                                        context)
        multiStepFeedback = QgsProcessingMultiStepFeedback(3, feedback)
        multiStepFeedback.setCurrentStep(0)
        frame = layerHandler.getFrameOutterBounds(frameLayer,
                                                  algRunner,
                                                  context,
                                                  feedback=multiStepFeedback)
        # get search radius
        searchRadius = self.parameterAsDouble(parameters, self.SEARCH_RADIUS,
                                              context)
        selectValid = self.parameterAsBool(parameters, self.SELECT_ALL_VALID,
                                           context)
        max_amount_cycles = self.parameterAsInt(parameters, self.MAX_CYCLES,
                                                context)
        nodeFlags, featList, nodeIdDict = networkHandler.verifyNetworkDirectioning(
            networkLayer,
            networkNodeLayer,
            frame,
            searchRadius,
            waterBodyClasses=waterBodyClasses,
            waterSinkLayer=waterSinkLayer,
            spillwayLayer=spillwayLayer,
            max_amount_cycles=max_amount_cycles,
            feedback=multiStepFeedback,
            selectValid=selectValid,
            ditchLayer=ditchLayer,
            attributeBlackList=attributeBlackList,
            excludePrimaryKeys=ignorePK,
            ignoreVirtualFields=ignoreVirtual)
        multiStepFeedback.setCurrentStep(1)
        #these are counted as one set of operations
        flag_line_sink_id = self.addFeaturesToFlagLineSink(
            featList, parameters, networkLayer, context)
        self.prepareFlagSink(parameters, networkLayer, QgsWkbTypes.Point,
                             context)
        self.buildFlagList(nodeFlags, networkLayer, nodeIdDict,
                           multiStepFeedback)

        return {
            self.NETWORK_LAYER: networkLayer,
            self.FLAGS: self.flag_id,
            self.LINE_FLAGS: flag_line_sink_id
        }