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 os

     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

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 GetAttrByRow(self, row, col, attr):

    41

        if col == 3:

    42

            attr.SetColour('blue')

    43

            attr.SetBold(True)

    44

            return True

    45

        return False

    46

    47

    48

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

    49

        if not ascending: # swap sort order?

    50

            item2, item1 = item1, item2

    51

        row1 = self.GetRow(item1)

    52

        row2 = self.GetRow(item2)

    53

        if col == 0:

    54

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

    55

        else:

    56

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

    57

    58

    def DeleteRows(self, rows):

    59

        rows = list(rows)

    60

        rows.sort(reverse=True)

    61

    62

        for row in rows:

    63

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

    64

            del self.data[row]

    65

            self.RowDeleted(row)

    66

        self._saveData()

    67

    68

    def AddRow(self, value):

    69

        self.data.append(value)

    70

        self.RowAppended()

    71

        self._saveData()

    72

    73

    def Import(self, filepath, sircb):

    74

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

    75

        if data is not None:

    76

            self.data = data

    77

            self.Reset(len(self.data)) 

    78

    79

    def Export(self, filepath):

    80

        PSK.ExportIDs(self.project_path, filepath)

    81

    82

colflags = dv.DATAVIEW_COL_RESIZABLE|dv.DATAVIEW_COL_SORTABLE

    83

    84

class IDBrowser(wx.Panel):

    85

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

    86

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

    87

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

    88

                                                  600 if big else 200))

    89

    90

        self.SelectURICallBack = SelectURICallBack

    91

        self.SelectIDCallBack = SelectIDCallBack

    92

    93

        dvStyle = wx.BORDER_THEME | dv.DV_ROW_LINES

    94

        if self.isManager :

    95

            # no multiple selection in selector mode

    96

            dvStyle |= dv.DV_MULTIPLE

    97

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

    98

    99

        args = lambda *a,**k:(a,k)

   100

   101

        ColumnsDesc = [

   102

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

   103

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

   104

            args(_("Description"), COL_DESC, width = 200, 

   105

                mode = dv.DATAVIEW_CELL_EDITABLE 

   106

                       if self.isManager 

   107

                       else dv.DATAVIEW_CELL_INERT),

   108

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

   109

        ]

   110

   111

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

   112

        self.dvc.AssociateModel(self.model)

   113

   114

        for a,k in ColumnsDesc:

   115

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

   116

   117

        # TODO : when select,

   118

        #  - update ID field of scheme editor

   119

        #  - enable use URI button

   120

   121

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

   122

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

   123

   124

        btnbox = wx.BoxSizer(wx.HORIZONTAL)

   125

        if self.isManager :

   126

   127

            # deletion of secret and metadata

   128

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

   129

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

   130

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

   131

   132

            # export all

   133

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

   134

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

   135

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

   136

   137

            # import with a merge -> duplicates are asked for

   138

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

   139

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

   140

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

   141

   142

        else :

   143

            # selector mode

   144

            # use last known URI button

   145

            # TODO : disable use URI button until something selected

   146

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

   147

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

   148

            self.useURIButton.Disable()

   149

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

   150

   151

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

   152

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

   153

   154

   155

    def OnDeleteButton(self, evt):

   156

        items = self.dvc.GetSelections()

   157

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

   158

   159

        # Ask if user really wants to delete

   160

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

   161

                         _('Delete IDs'),

   162

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

   163

            return

   164

   165

        self.model.DeleteRows(rows)

   166

   167

    def OnSelectionChanged(self, evt):

   168

        if not self.isManager :

   169

            items = self.dvc.GetSelections()

   170

            somethingSelected = len(items) > 0

   171

            self.useURIButton.Enable(somethingSelected)

   172

            if somethingSelected:

   173

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

   174

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

   175

                self.SelectIDCallBack(ID)

   176

   177

   178

    def OnUseURIButton(self, evt):

   179

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

   180

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

   181

        if URI:

   182

            self.SelectURICallBack(URI)

   183

   184

    def OnExportButton(self, evt):

   185

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

   186

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

   187

                               style = wx.SAVE | wx.OVERWRITE_PROMPT)

   188

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

   189

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

   190

   191

    def ShouldIReplaceCallback(self,existing,replacement):

   192

        ID,URI,DESC,LAST = existing

   193

        _ID,_URI,_DESC,_LAST = replacement

   194

        dlg = IDMergeDialog(self, 

   195

            _("Import IDs"), 

   196

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

   197

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

   198

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

   199

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

   200

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

   201

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

   202

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

   203

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

   204

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

   205

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

   206

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

   207

   208

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

   209

        if answer == wx.ID_CANCEL:

   210

            return CANCEL

   211

   212

        if dlg.OptionChecked():

   213

            if answer == wx.ID_YES:

   214

                return REPLACE_ALL

   215

            return KEEP_ALL

   216

        else:

   217

            if answer == wx.ID_YES:

   218

                return REPLACE

   219

            return KEEP

   220

   221

    def OnImportButton(self, evt):

   222

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

   223

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

   224

                               style = wx.FD_OPEN | wx.FD_FILE_MUST_EXIST)

   225

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

   226

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

   227

                              self.ShouldIReplaceCallback)

   228