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 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

colflags = dv.DATAVIEW_COL_RESIZABLE|dv.DATAVIEW_COL_SORTABLE

    75

    76

class IDBrowser(wx.Panel):

    77

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

    78

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

    80

                                                  600 if big else 200))

    81

    82

        self.SelectURICallBack = SelectURICallBack

    83

        self.SelectIDCallBack = SelectIDCallBack

    84

    85

        dvStyle = wx.BORDER_THEME | dv.DV_ROW_LINES

    86

        if self.isManager :

    87

            # no multiple selection in selector mode

    88

            dvStyle |= dv.DV_MULTIPLE

    89

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

    90

    91

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

    92

    93

        ColumnsDesc = [

    97

                mode = dv.DATAVIEW_CELL_EDITABLE 

    98

                       if self.isManager 

    99

                       else dv.DATAVIEW_CELL_INERT),

   100

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

   101

        ]

   102

   103

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

   104

        self.dvc.AssociateModel(self.model)

   105

   107

        for a,k in ColumnsDesc:

   113

   114

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

   115

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

   116

   117

        btnbox = wx.BoxSizer(wx.HORIZONTAL)

   118

        if self.isManager :

   119

   120

            # deletion of secret and metadata

   121

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

   122

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

   123

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

   124

   125

            # export all

   126

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

   127

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

   128

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

   129

   130

            # import with a merge -> duplicates are asked for

   131

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

   132

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

   133

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

   134

   135

        else :

   136

            # selector mode

   137

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

   138

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

   139

            self.useURIButton.Disable()

   140

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

   141

   142

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

   143

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

   144

   145

   146

    def OnDeleteButton(self, evt):

   147

        items = self.dvc.GetSelections()

   148

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

   149

   150

        # Ask if user really wants to delete

   151

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

   152

                         _('Delete IDs'),

   153

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

   154

            return

   155

   156

        self.model.DeleteRows(rows)

   157

   158

    def OnSelectionChanged(self, evt):

   159

        if not self.isManager :

   160

            items = self.dvc.GetSelections()

   161

            somethingSelected = len(items) > 0

   162

            self.useURIButton.Enable(somethingSelected)

   163

            if somethingSelected:

   164

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

   165

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

   166

                self.SelectIDCallBack(ID)

   167

   168

   169

    def OnUseURIButton(self, evt):

   170

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

   171

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

   172

        if URI:

   173

            self.SelectURICallBack(URI)

   174

   175

    def OnExportButton(self, evt):

   176

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

   177

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

   178

                               style = wx.SAVE | wx.OVERWRITE_PROMPT)

   179

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

   180

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

   181

   182

    def ShouldIReplaceCallback(self,existing,replacement):

   183

        ID,URI,DESC,LAST = existing

   184

        _ID,_URI,_DESC,_LAST = replacement

   185

        dlg = IDMergeDialog(self, 

   186

            _("Import IDs"), 

   187

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

   188

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

   189

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

   190

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

   191

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

   192

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

   193

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

   194

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

   195

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

   196

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

   197

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

   198

   199

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

   200

        if answer == wx.ID_CANCEL:

   201

            return CANCEL

   202

   203

        if dlg.OptionChecked():

   204

            if answer == wx.ID_YES:

   205

                return REPLACE_ALL

   206

            return KEEP_ALL

   207

        else:

   208

            if answer == wx.ID_YES:

   209

                return REPLACE

   210

            return KEEP

   211

   212

    def OnImportButton(self, evt):

   213

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

   214

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

   215

                               style = wx.FD_OPEN | wx.FD_FILE_MUST_EXIST)

   216

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

   217

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

   218

                              self.ShouldIReplaceCallback)

   219