Add 2 new functions: get_hyperlink_cells and get_sheet_protection

- Update unit tests

Author: xuri

excelize.py

@@ -3356,6 +3356,39 @@ def get_form_controls(self, sheet: str) -> List[FormControl]:
             return arr
         raise RuntimeError(err)
 
+    def get_hyperlink_cells(self, sheet: str, link_type: str) -> List[str]:
+        """
+        Returns cell references which contain hyperlinks in a given worksheet
+        name and link type. The optional parameter `link_type` use for specific
+        link type,the optional values are `External` for website links,
+        `Location` for moving to one of cell in this workbook, `None` for no
+        links. If `link_type` is empty, it will return all hyperlinks in the
+        worksheet.
+
+        Args:
+            sheet (str): The worksheet name
+            link_type (str): The hyperlink type to filter
+
+        Returns:
+            List[str]: Return the cell name list if no error occurred,
+            otherwise raise a RuntimeError with the message.
+        """
+        prepare_args(
+            [sheet, link_type],
+            [argsRule("sheet", [str]), argsRule("link_type", [str])],
+        )
+        lib.GetHyperLinkCells.restype = types_go._StringArrayErrorResult
+        res = lib.GetHyperLinkCells(
+            self.file_index,
+            sheet.encode(ENCODE),
+            link_type.encode(ENCODE),
+        )
+        arr = c_value_to_py(res, StringArrayErrorResult()).arr
+        err = res.Err.decode(ENCODE)
+        if not err:
+            return arr if arr else []
+        raise RuntimeError(err)
+
     def get_merge_cells(self, sheet: str, *without_values: bool) -> List[MergeCell]:
         """
         Get all merged cells from a specific worksheet. If the `without_values`
@@ -3793,6 +3826,27 @@ def get_sheet_props(self, sheet: str) -> Optional[SheetPropsOptions]:
             return c_value_to_py(res.opts, SheetPropsOptions())
         raise RuntimeError(err)
 
+    def get_sheet_protection(self, sheet: str) -> Optional[SheetProtectionOptions]:
+        """
+        Get worksheet protection settings by given worksheet name. Note that the
+        password in the returned will always be empty.
+
+        Args:
+            sheet (str): The sheet name.
+
+        Returns:
+            Optional[SheetProtectionOptions]: Return the sheet protection
+            options if no error occurred, otherwise raise a RuntimeError with
+            the message.
+        """
+        prepare_args([sheet], [argsRule("sheet", [str])])
+        lib.GetSheetProtection.restype = types_go._GetSheetProtectionResult
+        res = lib.GetSheetProtection(self.file_index, sheet.encode(ENCODE))
+        err = res.err.decode(ENCODE)
+        if not err:
+            return c_value_to_py(res.opts, SheetProtectionOptions())
+        raise RuntimeError(err)
+
     def get_sheet_view(self, sheet: str, view_index: int) -> Optional[ViewOptions]:
         """
         Gets the value of sheet view options. The view_index may be negative and

main.go

@@ -1457,8 +1457,8 @@ func GetFormControls(idx int, sheet *C.char) C.struct_GetFormControlsResult {
 		return C.struct_GetFormControlsResult{Err: C.CString(err.Error())}
 	}
 	cArray := C.malloc(C.size_t(len(opts)) * C.size_t(unsafe.Sizeof(C.struct_FormControl{})))
-	for i, dn := range opts {
-		cVal, err := goValueToC(reflect.ValueOf(dn), reflect.ValueOf(&C.struct_FormControl{}))
+	for i, opt := range opts {
+		cVal, err := goValueToC(reflect.ValueOf(opt), reflect.ValueOf(&C.struct_FormControl{}))
 		if err != nil {
 			return C.struct_GetFormControlsResult{Err: C.CString(err.Error())}
 		}
@@ -1467,6 +1467,29 @@ func GetFormControls(idx int, sheet *C.char) C.struct_GetFormControlsResult {
 	return C.struct_GetFormControlsResult{FormControlsLen: C.int(len(opts)), FormControls: (*C.struct_FormControl)(cArray), Err: C.CString(emptyString)}
 }
 
+// GetHyperLinkCells returns cell references which contain hyperlinks in a
+// given worksheet name and link type. The optional parameter 'linkType' use for
+// specific link type,the optional values are "External" for website links,
+// "Location" for moving to one of cell in this workbook, "None" for no links.
+// If linkType is empty, it will return all hyperlinks in the worksheet.
+//
+//export GetHyperLinkCells
+func GetHyperLinkCells(idx int, sheet, linkType *C.char) C.struct_StringArrayErrorResult {
+	f, ok := files.Load(idx)
+	if !ok {
+		return C.struct_StringArrayErrorResult{Err: C.CString(errFilePtr)}
+	}
+	result, err := f.(*excelize.File).GetHyperLinkCells(C.GoString(sheet), C.GoString(linkType))
+	if err != nil {
+		return C.struct_StringArrayErrorResult{Err: C.CString(err.Error())}
+	}
+	cArray := C.malloc(C.size_t(len(result)) * C.size_t(unsafe.Sizeof(uintptr(0))))
+	for i, v := range result {
+		*(*unsafe.Pointer)(unsafe.Pointer(uintptr(unsafe.Pointer(cArray)) + uintptr(i)*unsafe.Sizeof(uintptr(0)))) = unsafe.Pointer(C.CString(v))
+	}
+	return C.struct_StringArrayErrorResult{ArrLen: C.int(len(result)), Arr: (**C.char)(cArray), Err: C.CString(emptyString)}
+}
+
 // GetMergeCells provides a function to get all merged cells from a specific
 // worksheet. If the `withoutValues` parameter is set to true, it will not
 // return the cell values of merged cells, only the range reference will be
@@ -1794,6 +1817,27 @@ func GetSheetProps(idx int, sheet *C.char) C.struct_GetSheetPropsResult {
 	return C.struct_GetSheetPropsResult{opts: cVal.Elem().Interface().(C.struct_SheetPropsOptions), err: C.CString(emptyString)}
 }
 
+// GetSheetProtection provides a function to get worksheet protection settings
+// by given worksheet name. Note that the password in the returned will always
+// be empty.
+//
+//export GetSheetProtection
+func GetSheetProtection(idx int, sheet *C.char) C.struct_GetSheetProtectionResult {
+	f, ok := files.Load(idx)
+	if !ok {
+		return C.struct_GetSheetProtectionResult{err: C.CString(errFilePtr)}
+	}
+	opts, err := f.(*excelize.File).GetSheetProtection(C.GoString(sheet))
+	if err != nil {
+		return C.struct_GetSheetProtectionResult{err: C.CString(err.Error())}
+	}
+	cVal, err := goValueToC(reflect.ValueOf(opts), reflect.ValueOf(&C.struct_SheetProtectionOptions{}))
+	if err != nil {
+		return C.struct_GetSheetProtectionResult{err: C.CString(err.Error())}
+	}
+	return C.struct_GetSheetProtectionResult{opts: cVal.Elem().Interface().(C.struct_SheetProtectionOptions), err: C.CString(emptyString)}
+}
+
 // GetSheetView gets the value of sheet view options. The viewIndex may be
 // negative and if so is counted backward (-1 is the last view).
 //

test_excelize.py

@@ -872,6 +872,27 @@ def test_style(self):
             "expected type Options for argument 'opts', but got int",
         )
 
+        opts = excelize.SheetProtectionOptions(
+            select_locked_cells=True,
+            select_unlocked_cells=True,
+            edit_scenarios=True,
+        )
+        self.assertIsNone(f.protect_sheet("Sheet1", opts))
+        result = f.get_sheet_protection("Sheet1")
+        self.assertEqual(opts, result)
+
+        with self.assertRaises(RuntimeError) as context:
+            f.get_sheet_protection("SheetN")
+        self.assertEqual(str(context.exception), "sheet SheetN does not exist")
+        with self.assertRaises(TypeError) as context:
+            f.get_sheet_protection(1)
+        self.assertEqual(
+            str(context.exception),
+            "expected type str for argument 'sheet', but got int",
+        )
+
+        self.assertIsNone(f.unprotect_sheet("Sheet1"))
+
         self.assertIsNone(
             f.protect_sheet(
                 "Sheet1",
@@ -907,7 +928,6 @@ def test_style(self):
             "expected type str for argument 'password', but got int",
         )
         self.assertIsNone(f.unprotect_sheet("Sheet1", "password"))
-        self.assertIsNone(f.unprotect_sheet("Sheet1"))
 
         self.assertIsNone(
             f.protect_workbook(
@@ -1034,6 +1054,10 @@ def test_none_file_pointer(self):
         with self.assertRaises(RuntimeError) as context:
             f.get_form_controls("Sheet1")
         self.assertEqual(str(context.exception), expected)
+        self.assertEqual(str(context.exception), expected)
+        with self.assertRaises(RuntimeError) as context:
+            f.get_hyperlink_cells("Sheet1", "")
+        self.assertEqual(str(context.exception), expected)
         with self.assertRaises(RuntimeError) as context:
             f.get_page_layout("Sheet1")
         self.assertEqual(str(context.exception), expected)
@@ -1055,6 +1079,9 @@ def test_none_file_pointer(self):
             str(context.exception),
             "expected type int for argument 'sheet', but got str",
         )
+        with self.assertRaises(RuntimeError) as context:
+            f.get_sheet_protection("Sheet1")
+        self.assertEqual(str(context.exception), expected)
         with self.assertRaises(RuntimeError) as context:
             f.get_workbook_props()
         self.assertEqual(str(context.exception), expected)
@@ -2185,6 +2212,10 @@ def test_cell_hyperlink(self):
         self.assertTrue(link)
         self.assertEqual(target, display)
 
+        self.assertEqual(["A3"], f.get_hyperlink_cells("Sheet1", ""))
+        self.assertEqual([], f.get_hyperlink_cells("Sheet1", "Location"))
+        self.assertEqual([], f.get_hyperlink_cells("Sheet1", "None"))
+
         with self.assertRaises(RuntimeError) as context:
             _, _ = f.get_cell_hyperlink("SheetN", "A3")
         self.assertEqual(str(context.exception), "sheet SheetN does not exist")
@@ -2196,6 +2227,17 @@ def test_cell_hyperlink(self):
             "expected type str for argument 'cell', but got int",
         )
 
+        with self.assertRaises(RuntimeError) as context:
+            f.get_hyperlink_cells("SheetN", "")
+        self.assertEqual(str(context.exception), "sheet SheetN does not exist")
+
+        with self.assertRaises(TypeError) as context:
+            f.get_hyperlink_cells("Sheet1", 1)
+        self.assertEqual(
+            str(context.exception),
+            "expected type str for argument 'link_type', but got int",
+        )
+
         self.assertIsNone(f.save_as(os.path.join("test", "TestCellHyperLink.xlsx")))
         self.assertIsNone(f.close())
 

types_c.h

@@ -912,6 +912,12 @@ struct GetSheetPropsResult
     char *err;
 };
 
+struct GetSheetProtectionResult
+{
+    struct SheetProtectionOptions opts;
+    char *err;
+};
+
 struct GetSheetMapResult
 {
     int ArrLen;

types_go.py

@@ -896,6 +896,13 @@ class _GetSheetPropsResult(Structure):
     ]
 
 
+class _GetSheetProtectionResult(Structure):
+    _fields_ = [
+        ("opts", _SheetProtectionOptions),
+        ("err", c_char_p),
+    ]
+
+
 class _GetSheetMapResult(Structure):
     _fields_ = [
         ("ArrLen", c_int),