1

#!/usr/bin/env python

     2

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

     3

     4

# See COPYING file for copyrights details.

     5

     6

from __future__ import absolute_import

     7

import wx

     8

import wx.dataview as dv

     9

import PSKManagement as PSK

    10

from PSKManagement import *

    11

from dialogs.IDMergeDialog import IDMergeDialog

    12

    13

    14

class IDBrowserModel(dv.PyDataViewIndexListModel):

    15

    def __init__(self, project_path, columncount):

    16

        self.project_path = project_path

    17

        self.columncount = columncount

    18

        self.data = PSK.GetData(project_path)

    19

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

    20

    21

    def _saveData(self):

    22

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

    23

    24

    def GetColumnType(self, col):

    25

        return "string"

    26

    27

    def GetValueByRow(self, row, col):

    28

        return self.data[row][col]

    29

    30

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

    31

        self.data[row][col] = value

    32

        self._saveData()

    33

    34

    def GetColumnCount(self):

    35

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

    36

    37

    def GetCount(self):

    38

        return len(self.data)

    39

    40

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

    41

        if not ascending:  # swap sort order?

    42

            item2, item1 = item1, item2

    43

        row1 = self.GetRow(item1)

    44

        row2 = self.GetRow(item2)

    45

        if col == 0:

    46

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

    47

        else:

    48

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

    49

    50

    def DeleteRows(self, rows):

    51

        rows = list(rows)

    52

        rows.sort(reverse=True)

    53

    54

        for row in rows:

    55

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

    56

            del self.data[row]

    57

            self.RowDeleted(row)

    58

        self._saveData()

    59

    60

    def AddRow(self, value):

    61

        self.data.append(value)

    62

        self.RowAppended()

    63

        self._saveData()

    64

    65

    def Import(self, filepath, sircb):

    66

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

    67

        if data is not None:

    68

            self.data = data

    69

            self.Reset(len(self.data))

    70

    71

    def Export(self, filepath):

    72

        PSK.ExportIDs(self.project_path, filepath)

    73

    74

    75

colflags = dv.DATAVIEW_COL_RESIZABLE | dv.DATAVIEW_COL_SORTABLE

    76

    77

    78

class IDBrowser(wx.Panel):

    79

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

    80

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

    81

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

    82

                                                  600 if big else 200))

    83

    84

        self.SelectURICallBack = SelectURICallBack

    85

        self.SelectIDCallBack = SelectIDCallBack

    86

    87

        dvStyle = wx.BORDER_THEME | dv.DV_ROW_LINES

    88

        if self.isManager:

    89

            # no multiple selection in selector mode

    90

            dvStyle |= dv.DV_MULTIPLE

    91

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

    92

    93

        def args(*a, **k):

    94

            return (a, k)

    95

    96

        ColumnsDesc = [

    97

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

    98

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

    99

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

   100

                 mode=dv.DATAVIEW_CELL_EDITABLE

   101

                 if self.isManager

   102

                 else dv.DATAVIEW_CELL_INERT),

   103

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

   104

        ]

   105

   106

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

   107

        self.dvc.AssociateModel(self.model)

   108

   109

        col_list = []

   110

        for a, k in ColumnsDesc:

   111

            col_list.append(

   112

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

   113

        col_list[COL_LAST].SetSortOrder(False)

   114

   115

        # TODO : sort by last bvisit by default

   116

   117

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

   118

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

   119

   120

        btnbox = wx.BoxSizer(wx.HORIZONTAL)

   121

        if self.isManager:

   122

   123

            # deletion of secret and metadata

   124

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

   125

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

   126

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

   127

   128

            # export all

   129

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

   130

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

   131

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

   132

   133

            # import with a merge -> duplicates are asked for

   134

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

   135

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

   136

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

   137

   138

        else:

   139

            # selector mode

   140

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

   141

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

   142

            self.useURIButton.Disable()

   143

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

   144

   145

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

   146

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

   147

   148

    def OnDeleteButton(self, evt):

   149

        items = self.dvc.GetSelections()

   150

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

   151

   152

        # Ask if user really wants to delete

   153

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

   154

                         _('Delete IDs'),

   155

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

   156

            return

   157

   158

        self.model.DeleteRows(rows)

   159

   160

    def OnSelectionChanged(self, evt):

   161

        if not self.isManager:

   162

            items = self.dvc.GetSelections()

   163

            somethingSelected = len(items) > 0

   164

            self.useURIButton.Enable(somethingSelected)

   165

            if somethingSelected:

   166

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

   167

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

   168

                self.SelectIDCallBack(ID)

   169

   170

    def OnUseURIButton(self, evt):

   171

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

   172

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

   173

        if URI:

   174

            self.SelectURICallBack(URI)

   175

   176

    def OnExportButton(self, evt):

   177

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

   178

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

   179

                               style=wx.SAVE | wx.OVERWRITE_PROMPT)

   180

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

   181

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

   182

   183

    # pylint: disable=unused-variable

   184

    def ShouldIReplaceCallback(self, existing, replacement):

   185

        ID, URI, DESC, LAST = existing

   186

        _ID, _URI, _DESC, _LAST = replacement

   187

        dlg = IDMergeDialog(

   188

            self,

   189

            _("Import IDs"),

   190

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

   191

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

   192

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

   193

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

   194

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

   195

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

   196

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

   197

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

   198

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

   199

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

   200

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

   201

   202

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

   203

        if answer == wx.ID_CANCEL:

   204

            return CANCEL

   205

   206

        if dlg.OptionChecked():

   207

            if answer == wx.ID_YES:

   208

                return REPLACE_ALL

   209

            return KEEP_ALL

   210

        else:

   211

            if answer == wx.ID_YES:

   212

                return REPLACE

   213

            return KEEP

   214

   215

    def OnImportButton(self, evt):

   216

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

   217

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

   218

                               style=wx.FD_OPEN | wx.FD_FILE_MUST_EXIST)

   219

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

   220

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

   221

                              self.ShouldIReplaceCallback)