Example #1
0
 def Enable(self):
     """
     All real actions involved in initializing the service should
     be defined here, not in the constructor.  This includes
     e.g. opening sockets, collecting data from directories, etc.
     """
     import wx
     from solipsis.services.profile.gui.EditorFrame import EditorFrame
     from solipsis.services.profile.gui.ViewerFrame import ViewerFrame
     from solipsis.services.profile.gui.FilterFrame import FilterFrame
     set_solipsis_dir(self.service_api.GetDirectory())
     # init windows
     main_window = self.service_api.GetMainWindow()
     options = {}
     options["standalone"] = False
     self.editor_frame = EditorFrame(options, main_window, -1, "",
                                       plugin=self)
     self.viewer_frame = ViewerFrame(options, main_window, -1, "",
                                       plugin=self)
     self.filter_frame = FilterFrame(options, main_window, -1, "",
                                       plugin=self)
     # Set up main GUI hooks
     menu = wx.Menu()
     for action, method in self.MAIN_ACTION.iteritems():
         item_id = wx.NewId()
         menu.Append(item_id, _(action))
         wx.EVT_MENU(main_window, item_id, method)
     self.service_api.SetMenu(self.GetTitle(), menu)
     # launch network
     self.network = NetworkManager()
     self.activate(True)
Example #2
0
    def Enable(self):
        """
        All real actions involved in initializing the service should
        be defined here, not in the constructor.  This includes
        e.g. opening sockets, collecting data from directories, etc.
        """
        set_solipsis_dir(self.service_api.GetDirectory())
        # init windows
        main_window = self.service_api.GetMainWindow()
        # TODO: create dynamic option object (for standalone & display)
        options = {}
        options["standalone"] = False
        self.editor_frame = EditorFrame(options, main_window, -1, "", plugin=self)
        self.viewer_frame = ViewerFrame(options, main_window, -1, "", plugin=self)
        # Set up main GUI hooks
        menu = wx.Menu()
        for action, method in self.MAIN_ACTION.iteritems():
            item_id = wx.NewId()
            menu.Append(item_id, _(action))

            def _clicked(event):
                """call profile from main menu"""
                method()

            wx.EVT_MENU(main_window, item_id, _clicked)
        self.service_api.SetMenu(self.GetTitle(), menu)
        # launch network
        self.network = NetworkManager(self.host, random.randrange(7100, 7200), self.service_api)
        self.activate(True)
Example #3
0
class Plugin(ServicePlugin):
    """This the working class for services plugins."""
    
    # Define 'service_api' as a CLASS attribute
    service_api = ClassAttribute()
    
    def Init(self, local_ip):
        """
        This method does any kind of concrete initialization stuff,
        rather than doing it in __init__.  Especially, the service_api
        must *not* be used in __init__, since all data relating to the
        plugin may not have been initialized on the API side.
        """
        self.host = local_ip
        self.port = random.randrange(7000, 7100)
        self.network = None
        self.editor_frame = None
        self.viewer_frame = None
        self.filter_frame = None
        self.peer_services = {}
        # declare actions
        self.MAIN_ACTION = {_("Edit Profile..."): self.modify_profile,
                            _("Filter Profiles..."): self.filter_profile,
                            }
        self.POINT_ACTIONS = {#"View all...": self.show_profile,
                              _("View profile..."): self.get_profile,
                              _("View blog..."): self.get_blog_file,
                              _("Get files..."): self.select_files,}

    # Service setup

    # FIXME: need to abstract action layer of plugins so that it does
    # not depend on navigator mode (in our case: netclient or
    # wxclient)
    def EnableBasic(self):
        """enable non graphic part"""
        set_solipsis_dir(self.service_api.GetDirectory())
        self.network = NetworkManager()
        self.activate(True)
        
    def Enable(self):
        """
        All real actions involved in initializing the service should
        be defined here, not in the constructor.  This includes
        e.g. opening sockets, collecting data from directories, etc.
        """
        import wx
        from solipsis.services.profile.gui.EditorFrame import EditorFrame
        from solipsis.services.profile.gui.ViewerFrame import ViewerFrame
        from solipsis.services.profile.gui.FilterFrame import FilterFrame
        set_solipsis_dir(self.service_api.GetDirectory())
        # init windows
        main_window = self.service_api.GetMainWindow()
        options = {}
        options["standalone"] = False
        self.editor_frame = EditorFrame(options, main_window, -1, "",
                                          plugin=self)
        self.viewer_frame = ViewerFrame(options, main_window, -1, "",
                                          plugin=self)
        self.filter_frame = FilterFrame(options, main_window, -1, "",
                                          plugin=self)
        # Set up main GUI hooks
        menu = wx.Menu()
        for action, method in self.MAIN_ACTION.iteritems():
            item_id = wx.NewId()
            menu.Append(item_id, _(action))
            wx.EVT_MENU(main_window, item_id, method)
        self.service_api.SetMenu(self.GetTitle(), menu)
        # launch network
        self.network = NetworkManager()
        self.activate(True)
    
    def Disable(self):
        """It is called when the user chooses to disable the service."""
        # ask for saving (ca not simply call Close() on editor frame
        # method because of multithreading and the frame is destroyed
        # before the user actually answer to the popup
        if self.editor_frame and self.editor_frame.modified:
            import wx
            self.editor_frame.do_modified(False)
            dlg = wx.MessageDialog(
                self.editor_frame,
                'Your profile has been modified. Do you want to save it?',
                'Saving Profile',
                wx.YES_NO | wx.ICON_INFORMATION)
            if dlg.ShowModal() == wx.ID_YES:
                get_facade()._desc.save()
        if self.filter_frame and self.filter_frame.modified:
            import wx
            self.filter_frame.do_modified(False)
            dlg = wx.MessageDialog(
                self.filter_frame,
                'Your filters have been modified. Do you want to save them?',
                'Saving Filters',
                wx.YES_NO | wx.ICON_INFORMATION)
            if dlg.ShowModal() == wx.ID_YES:
                get_filter_facade().save()
        self.activate(False)

    def activate(self, active=True):
        """eable/disable service"""
        if not active:
            self.network.stop()
            for peer_id in self.peer_services.keys():
                self.LostPeer(peer_id)
        else:
            self.network.start()
            for peer_id in self.peer_services.keys():
                self.NewPeer(*self.peer_services[peer_id])

    # Service methods
    def modify_profile(self, evt):
        """display profile once loaded"""
        if not self.editor_frame is None:
            self.editor_frame.Show()
            
    def filter_profile(self, evt):
        """display profile once loaded"""
        if not self.filter_frame is None:
            self.filter_frame.Show()
            
#     def show_profile(self, evt):
#         """display profile once loaded"""
#         if self.viewer_frame:
#             self.viewer_frame.Show()

    def get_profile(self, peer_id, deferred=None):
        """request downwload of profile"""
        on_done = self.network.get_profile(peer_id)
        if on_done != None:
            on_done.addCallback(self._on_new_profile, peer_id)
            deferred and on_done.chainDeferred(deferred)

    def get_blog_file(self, peer_id, deferred=None):
        """request downwload of blog"""
        on_done = self.network.get_blog_file(peer_id)
        if on_done != None:
            on_done.addCallback(self._on_new_blog, peer_id)
            deferred and on_done.chainDeferred(deferred)

    def select_files(self, peer_id, deferred=None):
        """request downwload of list of shared files"""
        on_done = self.network.get_shared_files(peer_id)
        if on_done != None:
            on_done.addCallback(self._on_shared_files, peer_id)
            deferred and on_done.chainDeferred(deferred)

    def get_files(self, peer_id, file_descriptors):
        """request downwload of given files.

        file_descriptor is a list: [ [split path], size ]"""
        self.network.get_files(peer_id, file_descriptors)

    # callbacks methods
    def _on_new_profile(self, document, peer_id):
        """store and display file object corresponding to profile"""
        get_facade().fill_data(peer_id, document)
        return str(document)
            
    def _on_new_blog(self, blog, peer_id):
        """store and display file object corresponding to blog"""
        get_facade().fill_blog(peer_id, blog)
        return str(blog)
    
    def _on_shared_files(self, files, peer_id):
        """store and display file object corresponding to blog"""
        get_facade().fill_shared_files(peer_id, files)
        return str(files)

    # Service description methods
    def GetTitle(self):
        """Returns a short title of the plugin."""
        return _("Profile")

    def GetDescription(self):
        """Returns a short description of the plugin. """
        return _("Manage personal information and share it with people")

    def GetActions(self):
        """Returns an array of strings advertising possible actions
        with all peers, or None if no such action is allowed.
        """
        return [_(desc) for desc in self.MAIN_ACTION]

    def GetPointToPointActions(self):
        """Returns an array of strings advertising point-to-point
        actions with another peer, or None if point-to-point actions
        are not allowed.
        """
        return [_(desc) for desc in self.POINT_ACTIONS]

    def DescribeService(self, service):
        """
        Fills the Service object used to describe the service to other peers.
        """
        service.address = "%s:%d" % (self.host, self.port)

    # UI event responses
    def DoAction(self, it, deferred=None):
        """Called when the general action is invoked, if available."""
        # retreive corect method
        actions = self.MAIN_ACTION.values()
        # call method on peer
        actions[it](deferred)

    def DoPointToPointAction(self, it, peer, deferred=None):
        """Called when a point-to-point action is invoked, if available."""
        if get_facade() and get_facade()._activated:
            # retreive corect method
            actions = self.POINT_ACTIONS.values()
            # call method on peer
            actions[it](peer.id_, deferred)
        # service not activated, do nothing
        else:
            print "service not activated"
            

    # Peer management
    # FIXME: check really need to call network method
    def NewPeer(self, peer, service):
        """delegate to network"""
        self.peer_services[peer.id_] = (peer, service)
        if get_facade() and get_facade()._activated:
            self.network.on_new_peer(peer)

    def ChangedPeer(self, peer, service):
        """delegate to network"""
        self.peer_services[peer.id_] = (peer, service)
        if get_facade() and get_facade()._activated:
            self.network.on_change_peer(peer, service)

    def LostPeer(self, peer_id):
        """delegate to network"""
        del self.peer_services[peer_id]
        if get_facade() and get_facade()._activated:
            self.network.on_lost_peer(peer_id)
            get_facade().set_connected(peer_id, False)

    def GotServiceData(self, peer_id, data):
        """delegate to network"""
        if get_facade() and get_facade()._activated:
            self.network.on_service_data(peer_id, data)

    def ChangedNode(self, node):
        """need to update node_id"""
        # ChangedNode is call more than one time on change. Thus, be
        # careful not to do the job every time
        if get_facade() is None or get_facade()._desc.document.get_pseudo() != node.pseudo:
            # creation
            facade = create_facade(node.id_)
            filter_facade = create_filter_facade(node.id_)
            if not facade.load():
                display_status(_("You have no profile yet for pseudo %s"% node.pseudo))
# ChangedNode called too many times at startup and make this popup appear several times => bother
# Replace by display_status for now
#                 display_message(
#                     _(u"You have no profile yet for pseudo %s.\n\n "
#                       "You may create one clicking on the menu Profile, "
#                       "and selecting 'Modify Profile'"% node.pseudo),
#                     title=_("New profile"))
            if not filter_facade.load():
                display_status(_("You have no filters defined yet for pseudo %s"% node.pseudo))
# ChangedNode called too many times at startup and make this popup appear several times => bother
# Replace by display_status for now
#                 display_message(
#                     _(u"You have no filters defined yet for pseudo %s.\n\n Filters are used "
#                       "to match your neighbors' profile and alert you if they "
#                       "match with your criteria.\n\n"
#                       "You may create your filters by clicking on the menu 'Profile', "
#                       "and selecting 'Filter Profiles'"% node.pseudo),
#                     title=_("New filters"))
            facade.change_pseudo(node.pseudo)
            # updating views
            if self.editor_frame:
                facade.add_view(EditorView(facade._desc,
                                           self.editor_frame))
                self.editor_frame.on_change_facade()
                facade.add_view(ViewerView(facade._desc,
                                           self.viewer_frame))
                self.viewer_frame.on_change_facade()
            if self.filter_frame:
                filter_facade.add_view(FilterView(filter_facade._desc,
                                                  self.filter_frame))
                self.filter_frame.on_change_facade()
            display_status(_("Loaded data for %s"% node.pseudo))
Example #4
0
class Plugin(ServicePlugin):
    """This the working class for services plugins."""
    
    def Init(self, local_ip):
        """
        This method does any kind of concrete initialization stuff,
        rather than doing it in __init__.  Especially, the service_api
        must *not* be used in __init__, since all data relating to the
        plugin may not have been initialized on the API side.
        """
        self.host = local_ip
        self.port = random.randrange(7000, 7100)
        self.network = None
        self.editor_frame = None
        self.filter_frame = None
        self.peer_services = {}
        # declare actions
        self.MAIN_ACTION = {"Modify Profile...": self.modify_profile,
                            "Filter Profiles...": self.filter_profile,
                            }
        self.POINT_ACTIONS = {#"View all...": self.show_profile,
                              "View profile...": self.get_profile,
                              "View blog...": self.get_blog_file,
                              "Get files...": self.select_files,}

    # Service setup

    # FIXME: need to abstract action layer of plugins so that it does
    # not depend on navigator mode (in our case: netclient or
    # wxclient)
    def EnableBasic(self):
        """enable non graphic part"""
        set_solipsis_dir(self.service_api.GetDirectory())
        self.network = NetworkManager(self.host,
                                      random.randrange(7100, 7200),
                                      self.service_api)
        self.activate(True)
        
    def Enable(self):
        """
        All real actions involved in initializing the service should
        be defined here, not in the constructor.  This includes
        e.g. opening sockets, collecting data from directories, etc.
        """
        set_solipsis_dir(self.service_api.GetDirectory())
        # init windows
        main_window = self.service_api.GetMainWindow()
        options = {}
        options["standalone"] = False
        self.editor_frame = EditorFrame(options, main_window, -1, "",
                                          plugin=self)
        self.viewer_frame = ViewerFrame(options, main_window, -1, "",
                                          plugin=self)
        self.filter_frame = FilterFrame(options, main_window, -1, "",
                                          plugin=self)
        # Set up main GUI hooks
        menu = wx.Menu()
        for action, method in self.MAIN_ACTION.iteritems():
            item_id = wx.NewId()
            menu.Append(item_id, _(action))
            wx.EVT_MENU(main_window, item_id, method)
        self.service_api.SetMenu(self.GetTitle(), menu)
        # launch network
        self.network = NetworkManager(self.host,
                                      random.randrange(7100, 7200),
                                      self.service_api,
                                      self.editor_frame.download_dlg)
        self.activate(True)
    
    def Disable(self):
        """It is called when the user chooses to disable the service."""
        # ask for saving (ca not simply call Close() on editor frame
        # method because of multithreading and the frame is destroyed
        # before the user actually answer to the popup
        if self.editor_frame.modified:
            self.editor_frame.do_modified(False)
            dlg = wx.MessageDialog(
                self.editor_frame,
                'Your profile has been modified. Do you want to save it?',
                'Saving Profile',
                wx.YES_NO | wx.ICON_INFORMATION)
            if dlg.ShowModal() == wx.ID_YES:
                get_facade().save()
        if self.filter_frame.modified:
            self.filter_frame.do_modified(False)
            dlg = wx.MessageDialog(
                self.editor_frame,
                'Your filters have been modified. Do you want to save them?',
                'Saving Filters',
                wx.YES_NO | wx.ICON_INFORMATION)
            if dlg.ShowModal() == wx.ID_YES:
                get_filter_facade().save()
        self.activate(False)

    # Service methods
    def modify_profile(self, evt=None):
        """display profile once loaded"""
        if self.editor_frame:
            self.editor_frame.Show()
            
    def filter_profile(self, evt=None):
        """display profile once loaded"""
        if self.filter_frame:
            self.filter_frame.Show()
            
    def show_profile(self, peer_id):
        """display profile once loaded"""
        if self.viewer_frame:
            self.viewer_frame.Show(peer_id)

    def get_profile(self, peer_id):
        """request downwload of profile"""
        deferred = self.network.get_profile(peer_id)
        deferred and deferred.addCallback(self._on_new_profile, peer_id)

    def get_blog_file(self, peer_id):
        """request downwload of blog"""
        deferred = self.network.get_blog_file(peer_id)
        deferred and deferred.addCallback(self._on_new_blog, peer_id)

    def get_files(self, peer_id, file_descriptors):
        """request downwload of given files"""
        if self.editor_frame and get_prefs().get("display_dl"):
            self.editor_frame.download_dlg.init()
            self.editor_frame.download_dlg.Show()
        deferred = self.network.get_files(peer_id, file_descriptors,
                                          self._on_all_files)
        deferred and deferred.addCallback(
            lambda file_name: sys.stdout.write("%s downloaded\n"% file_name))

    def select_files(self, peer_id):
        """request downwload of list of shared files"""
        deferred = self.network.get_shared_files(peer_id)
        deferred and deferred.addCallback(self._on_shared_files, peer_id)

    def activate(self, active=True):
        """eable/disable service"""
        if not active:
            self.network.stop_listening()
            self.network.disconnect()
        else:
            self.network.start_listening()
            for peer_id in self.peer_services.keys():
                self.NewPeer(*self.peer_services[peer_id])

    # callbacks methods
    def _on_new_profile(self, document, peer_id):
        """store and display file object corresponding to profile"""
        print "downloaded profile", peer_id
        get_facade().fill_data((peer_id, document))
        if self.viewer_frame:
            self.viewer_frame.profile_dlg.activate()
            self.viewer_frame.profile_dlg.Show()
            
    def _on_new_blog(self, blog, peer_id):
        """store and display file object corresponding to blog"""
        if self.viewer_frame:
            self.viewer_frame.peer_dlg.activate()
        get_facade().fill_blog((peer_id, blog))
    
    def _on_shared_files(self, files, peer_id):
        """store and display file object corresponding to blog"""
        if self.viewer_frame:
            self.viewer_frame.file_dlg.activate()
        get_facade().fill_shared_files((peer_id, files))
    
    def _on_all_files(self):
        """store and display file object corresponding to blog"""
        if self.editor_frame:
            self.editor_frame.download_dlg.complete_all_files()
        else:
            print 'No more file to download'

    # Service description methods
    def GetTitle(self):
        """Returns a short title of the plugin."""
        return _("Profile")

    def GetDescription(self):
        """Returns a short description of the plugin. """
        return _("Manage personal information and share it with people")

    def GetActions(self):
        """Returns an array of strings advertising possible actions
        with all peers, or None if no such action is allowed.
        """
        return [_(desc) for desc in self.MAIN_ACTION]

    def GetPointToPointActions(self):
        """Returns an array of strings advertising point-to-point
        actions with another peer, or None if point-to-point actions
        are not allowed.
        """
        return [_(desc) for desc in self.POINT_ACTIONS]

    def DescribeService(self, service):
        """
        Fills the Service object used to describe the service to other peers.
        """
        service.address = "%s:%d" % (self.host, self.port)

    # UI event responses
    def DoAction(self, it):
        """Called when the general action is invoked, if available."""
        # retreive corect method
        actions = self.MAIN_ACTION.values()
        # call method on peer
        actions[it]()

    def DoPointToPointAction(self, it, peer):
        """Called when a point-to-point action is invoked, if available."""
        if get_facade() and get_facade().is_activated():
            # retreive corect method
            actions = self.POINT_ACTIONS.values()
            # call method on peer
            actions[it](peer.id_)
        # service not activated, do nothing
        else:
            print "service not activated"
            

    # Peer management
    # FIXME: check really need to call network method
    def NewPeer(self, peer, service):
        """delegate to network"""
        self.peer_services[peer.id_] = (peer, service)
        if get_facade() and get_facade().is_activated():
            self.network.on_new_peer(peer, service)

    def ChangedPeer(self, peer, service):
        """delegate to network"""
        self.peer_services[peer.id_] = (peer, service)
        if get_facade() and get_facade().is_activated():
            self.network.on_change_peer(peer, service)

    def LostPeer(self, peer_id):
        """delegate to network"""
        del self.peer_services[peer_id]
        if get_facade() and get_facade().is_activated():
            self.network.on_lost_peer(peer_id)
            get_facade().set_connected((peer_id, False))

    def GotServiceData(self, peer_id, data):
        """delegate to network"""
        if get_facade() and get_facade().is_activated():
            self.network.on_service_data(peer_id, data)

    def ChangedNode(self, node):
        """need to update node_id"""
        # ChangedNode is call more than one time on change. Thus, be
        # careful not to do the job every time
        if get_facade() is None or get_facade().get_pseudo() != node.pseudo:
            facade = create_facade(node.pseudo)
            facade.load()
            if self.editor_frame:
                facade.add_view(EditorView(facade._desc,
                                           self.editor_frame))
                self.editor_frame.on_change_facade()
                facade.add_view(ViewerView(facade._desc,
                                           self.viewer_frame))
                self.viewer_frame.on_change_facade()
            filter_facade = create_filter_facade(node.pseudo)
            filter_facade.load()
            if self.filter_frame:
                filter_facade.add_view(FilterView(filter_facade._desc,
                                                  self.filter_frame))
                self.filter_frame.on_change_facade()