1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

# See COPYING file for copyrights details.

     5

     6

     7

from operator import eq

     8

import wx

     9

import wx.dataview as dv

    10

import PSKManagement as PSK

    11

from PSKManagement import *

    12

from dialogs.IDMergeDialog import IDMergeDialog

    13

    14

    15

class IDBrowserModel(dv.PyDataViewIndexListModel):

    16

    def __init__(self, project_path, columncount):

    17

        self.project_path = project_path

    18

        self.columncount = columncount

    19

        self.data = PSK.GetData(project_path)

    20

        dv.PyDataViewIndexListModel.__init__(self, len(self.data))

    21

    22

    def _saveData(self):

    23

        PSK.SaveData(self.project_path, self.data)

    24

    25

    def GetColumnType(self, col):

    26

        return "string"

    27

    28

    def GetValueByRow(self, row, col):

    29

        return self.data[row][col]

    30

    31

    def SetValueByRow(self, value, row, col):

    32

        self.data[row][col] = value

    33

        self._saveData()

    34

    35

    def GetColumnCount(self):

    36

        return len(self.data[0]) if self.data else self.columncount

    37

    38

    def GetCount(self):

    39

        return len(self.data)

    40

    41

    def Compare(self, item1, item2, col, ascending):

    42

        if not ascending:  # swap sort order?

    43

            item2, item1 = item1, item2

    44

        row1 = self.GetRow(item1)

    45

        row2 = self.GetRow(item2)

    46

        if col == 0:

    47

            return eq(int(self.data[row1][col]), int(self.data[row2][col]))

    48

        else:

    49

            return eq(self.data[row1][col], self.data[row2][col])

    50

    51

    def DeleteRows(self, rows):

    52

        rows = list(rows)

    53

        rows.sort(reverse=True)

    54

    55

        for row in rows:

    56

            PSK.DeleteID(self.project_path, self.data[row][COL_ID])

    57

            del self.data[row]

    58

            self.RowDeleted(row)

    59

        self._saveData()

    60

    61

    def AddRow(self, value):

    62

        self.data.append(value)

    63

        self.RowAppended()

    64

        self._saveData()

    65

    66

    def Import(self, filepath, sircb):

    67

        data = PSK.ImportIDs(self.project_path, filepath, sircb)

    68

        if data is not None:

    69

            self.data = data

    70

            self.Reset(len(self.data))

    71

    72

    def Export(self, filepath):

    73

        PSK.ExportIDs(self.project_path, filepath)

    74

    75

    76

colflags = dv.DATAVIEW_COL_RESIZABLE | dv.DATAVIEW_COL_SORTABLE

    77

    78

    79

class IDBrowser(wx.Panel):

    80

    def __init__(self, parent, ctr, SelectURICallBack=None, SelectIDCallBack=None, **kwargs):

    81

        big = self.isManager = SelectURICallBack is None and SelectIDCallBack is None

    82

        wx.Panel.__init__(self, parent, -1, size=(800 if big else 450,

    83

                                                  600 if big else 200))

    84

    85

        self.SelectURICallBack = SelectURICallBack

    86

        self.SelectIDCallBack = SelectIDCallBack

    87

    88

        dvStyle = wx.BORDER_THEME | dv.DV_ROW_LINES

    89

        if self.isManager:

    90

            # no multiple selection in selector mode

    91

            dvStyle |= dv.DV_MULTIPLE

    92

        self.dvc = dv.DataViewCtrl(self, style=dvStyle)

    93

    94

        def args(*a, **k):

    95

            return (a, k)

    96

    97

        ColumnsDesc = [

    98

            args(_("ID"), COL_ID, width=70),

    99

            args(_("Last URI"), COL_URI, width=300 if big else 80),

   100

            args(_("Description"), COL_DESC, width=300 if big else 200,

   101

                 mode=dv.DATAVIEW_CELL_EDITABLE

   102

                 if self.isManager

   103

                 else dv.DATAVIEW_CELL_INERT),

   104

            args(_("Last connection"), COL_LAST, width=120),

   105

        ]

   106

   107

        self.model = IDBrowserModel(ctr.ProjectPath, len(ColumnsDesc))

   108

        self.dvc.AssociateModel(self.model)

   109

   110

        col_list = []

   111

        for a, k in ColumnsDesc:

   112

            col_list.append(

   113

                self.dvc.AppendTextColumn(*a, **dict(k, flags=colflags)))

   114

        col_list[COL_LAST].SetSortOrder(False)

   115

   116

        # TODO : sort by last bvisit by default

   117

   118

        self.Sizer = wx.BoxSizer(wx.VERTICAL)

   119

        self.Sizer.Add(self.dvc, 1, wx.EXPAND)

   120

   121

        btnbox = wx.BoxSizer(wx.HORIZONTAL)

   122

        if self.isManager:

   123

   124

            # deletion of secret and metadata

   125

            deleteButton = wx.Button(self, label=_("Delete ID"))

   126

            self.Bind(wx.EVT_BUTTON, self.OnDeleteButton, deleteButton)

   127

            btnbox.Add(deleteButton, 0, wx.LEFT | wx.RIGHT, 5)

   128

   129

            # export all

   130

            exportButton = wx.Button(self, label=_("Export all"))

   131

            self.Bind(wx.EVT_BUTTON, self.OnExportButton, exportButton)

   132

            btnbox.Add(exportButton, 0, wx.LEFT | wx.RIGHT, 5)

   133

   134

            # import with a merge -> duplicates are asked for

   135

            importButton = wx.Button(self, label=_("Import"))

   136

            self.Bind(wx.EVT_BUTTON, self.OnImportButton, importButton)

   137

            btnbox.Add(importButton, 0, wx.LEFT | wx.RIGHT, 5)

   138

   139

        else:

   140

            # selector mode

   141

            self.useURIButton = wx.Button(self, label=_("Use last URI"))

   142

            self.Bind(wx.EVT_BUTTON, self.OnUseURIButton, self.useURIButton)

   143

            self.useURIButton.Disable()

   144

            btnbox.Add(self.useURIButton, 0, wx.LEFT | wx.RIGHT, 5)

   145

   146

        self.Sizer.Add(btnbox, 0, wx.TOP | wx.BOTTOM, 5)

   147

        self.Bind(dv.EVT_DATAVIEW_SELECTION_CHANGED, self.OnSelectionChanged, self.dvc)

   148

   149

    def OnDeleteButton(self, evt):

   150

        items = self.dvc.GetSelections()

   151

        rows = [self.model.GetRow(item) for item in items]

   152

   153

        # Ask if user really wants to delete

   154

        if wx.MessageBox(_('Are you sure to delete selected IDs?'),

   155

                         _('Delete IDs'),

   156

                         wx.YES_NO | wx.CENTRE | wx.NO_DEFAULT) != wx.YES:

   157

            return

   158

   159

        self.model.DeleteRows(rows)

   160

   161

    def OnSelectionChanged(self, evt):

   162

        if not self.isManager:

   163

            items = self.dvc.GetSelections()

   164

            somethingSelected = len(items) > 0

   165

            self.useURIButton.Enable(somethingSelected)

   166

            if somethingSelected:

   167

                row = self.model.GetRow(items[0])

   168

                ID = self.model.GetValueByRow(row, COL_ID)

   169

                self.SelectIDCallBack(ID)

   170

   171

    def OnUseURIButton(self, evt):

   172

        row = self.model.GetRow(self.dvc.GetSelections()[0])

   173

        URI = self.model.GetValueByRow(row, COL_URI)

   174

        if URI:

   175

            self.SelectURICallBack(URI)

   176

   177

    def OnExportButton(self, evt):

   178

        dialog = wx.FileDialog(self, _("Choose a file"),

   179

                               wildcard=_("PSK ZIP files (*.zip)|*.zip"),

   180

                               style=wx.SAVE | wx.OVERWRITE_PROMPT)

   181

        if dialog.ShowModal() == wx.ID_OK:

   182

            self.model.Export(dialog.GetPath())

   183

   184

    # pylint: disable=unused-variable

   185

    def ShouldIReplaceCallback(self, existing, replacement):

   186

        ID, URI, DESC, LAST = existing

   187

        _ID, _URI, _DESC, _LAST = replacement

   188

        dlg = IDMergeDialog(

   189

            self,

   190

            _("Import IDs"),

   191

            (_("Replace information for ID {ID} ?") + "\n\n" +

   192

             _("Existing:") + "\n    " +

   193

             _("Description:") + " {DESC}\n    " +

   194

             _("Last known URI:") + " {URI}\n    " +

   195

             _("Last connection:") + " {LAST}\n\n" +

   196

             _("Replacement:") + "\n    " +

   197

             _("Description:") + " {_DESC}\n    " +

   198

             _("Last known URI:") + " {_URI}\n    " +

   199

             _("Last connection:") + " {_LAST}\n").format(**locals()),

   200

            _("Do the same for following IDs"),

   201

            [_("Replace"), _("Keep"), _("Cancel")])

   202

   203

        answer = dlg.ShowModal()  # return value ignored as we have "Ok" only anyhow

   204

        if answer == wx.ID_CANCEL:

   205

            return CANCEL

   206

   207

        if dlg.OptionChecked():

   208

            if answer == wx.ID_YES:

   209

                return REPLACE_ALL

   210

            return KEEP_ALL

   211

        else:

   212

            if answer == wx.ID_YES:

   213

                return REPLACE

   214

            return KEEP

   215

   216

    def OnImportButton(self, evt):

   217

        dialog = wx.FileDialog(self, _("Choose a file"),

   218

                               wildcard=_("PSK ZIP files (*.zip)|*.zip"),

   219

                               style=wx.FD_OPEN | wx.FD_FILE_MUST_EXIST)

   220

        if dialog.ShowModal() == wx.ID_OK:

   221

            self.model.Import(dialog.GetPath(),

   222

                              self.ShouldIReplaceCallback)