Example #1
0
    def new(self):

        if self.unsaved is True:
            self.notification.showError(
                self, "Fixity",
                str(GUILibraries.messages['save_other_projects']))
            return

        QID = GUILibraries.QInputDialog(self)
        QID.setWindowModality(GUILibraries.Qt.WindowModal)
        name = QID.getText(self,
                           "Project Name",
                           "Name for new Fixity project:",
                           text="New_Project")

        if not name[1]:
            if len(self.Fixity.ProjectsList) <= 0:
                self.update_menu.setDisabled(True)
                self.delete_menu.setDisabled(True)
            return

        is_project_name_valid = self.Fixity.Validation.ValidateProjectName(
            name[0])
        if not is_project_name_valid:
            self.notification.showError(
                self, "Fixity",
                str(GUILibraries.messages['in_valid_project_name']))
            return

        project_info = self.Fixity.Database.select(
            self.Fixity.Database._tableProject, 'id',
            'title="' + name[0] + '"')

        if len(project_info) > 0:
            self.notification.showError(
                self, "Fixity",
                str(GUILibraries.messages['in_valid_project_name_detailed']))
            return

        self.update_menu.setDisabled(False)
        self.delete_menu.setDisabled(False)
        new_item = GUILibraries.QListWidgetItem(name[0], self.projects)

        self.projects.setCurrentItem(new_item)
        self.monthly.setChecked(True)
        self.monthClick()
        self.day_of_month.setValue(1)
        self.timer.setTime(GUILibraries.QTime(0, 0))

        for SingleRangeValue in xrange(
                0, self.Fixity.Configuration.getNumberOfPathDirectories()):
            self.dirs_text_fields[SingleRangeValue].setText("")
            self.mail_text_fields[SingleRangeValue].setText("")

        self.toggler(False)
        self.unsaved = True
        self.toggleEmailFields()
        if new_item:
            self.old = new_item
Example #2
0
    def delete(self):
        try:
            response = self.notification.showQuestion(
                self, 'Delete Project?',
                str(GUILibraries.messages['sure_delete']) +
                self.projects.currentItem().text() + "?")
        except:
            self.Fixity.logger.LogException(Exception.message)
            return

        if response:
            try:
                project_core = self.Fixity.ProjectRepo.getSingleProject(
                    self.projects.currentItem().text())

                project_core.Delete()

            except:
                pass
            self.unsaved = False
            self.projects.takeItem(
                self.projects.row(self.projects.currentItem()))
            self.unsaved = True
            for SingleRangeValue in xrange(
                    0, self.Fixity.Configuration.getNumberOfPathDirectories()):
                self.dirs_text_fields[SingleRangeValue].setText("")
                self.mail_text_fields[SingleRangeValue].setText("")

            self.monthly.setChecked(True)
            self.monthClick()
            self.timer.setTime(GUILibraries.QTime(0, 0))
            self.lastrun.setText("Last checked:\n --")
            self.toggler((self.projects.count() == 0))
            self.unsaved = False
            self.update(False)
            if len(self.Fixity.ProjectsList) <= 0:
                self.toggler(True)
                self.togglerMenu(True)
Example #3
0
    def update(self, new='', project_name_force=None):

        if self.should_update is False:
            return

        if self.unsaved:

            response = self.notification.showQuestion(
                self, 'Unsaved Project',
                GUILibraries.messages['new_project_unsaved'])

            if response:

                self.should_update = False
                self.unsaved = False

                if self.old:
                    try:
                        self.projects.setCurrentRow(
                            self.projects.indexFromItem(self.old).row())
                    except:
                        self.projects.setCurrentRow(0)
                        pass
                else:
                    self.projects.setCurrentRow(0)

                self.should_update = True

                self.unsaved = True
                self.old = self.projects.currentItem()
                return

            else:

                selected = int(self.projects.currentIndex().row())
                self.unsaved = False
                self.refreshProjectSettings()
                self.unsaved = False
                self.projects.setCurrentRow(selected)

        try:
            project_name = self.projects.currentItem().text()
        except:
            project_name = ''

        try:
            project_core = self.Fixity.ProjectRepo.getSingleProject(
                project_name)

        except:
            self.Fixity.logger.LogException(Exception.message)
            pass
        try:
            if project_core is False:
                return
        except:
            return

        for n in range(0,
                       self.Fixity.Configuration.getNumberOfPathDirectories()):
            self.dirs_text_fields[(n)].setText("")
            self.mail_text_fields[(n)].setText("")

        self.run_only_on_ac_power.setChecked(False)
        self.start_when_available.setChecked(False)
        self.email_only_when_something_changed.setChecked(False)

        emails = str(project_core.getEmail_address())
        emails = emails.split(',')
        last_run_label = project_core.getLast_ran()

        countEmail = 0
        for email in emails:
            try:
                self.mail_text_fields[(countEmail)].setText(str(email).strip())
            except:
                pass
            countEmail += 1

        directories = project_core.getDirectories()
        for n in directories:
            try:
                try:
                    self.dirs_text_fields[(n)].setText(
                        directories[(n)].getPath())
                except:
                    self.dirs_text_fields[(n)].setText(
                        str(directories[(n)].getPath()).strip())
                    pass

            except:
                try:
                    self.dirs_text_fields[(n)].setText("")
                except:
                    pass
                pass

        if int(project_core.scheduler.getEmail_only_upon_warning()) == 1:
            self.email_only_when_something_changed.setChecked(True)
        elif int(project_core.scheduler.getEmail_only_upon_warning()) == 0:
            self.email_only_when_something_changed.setChecked(False)

        if int(project_core.scheduler.getRun_when_on_battery()) == 1:
            self.run_only_on_ac_power.setChecked(True)
        elif int(project_core.scheduler.getRun_when_on_battery()) == 0:
            self.run_only_on_ac_power.setChecked(False)

        if int(project_core.scheduler.getIf_missed_run_upon_restart()) == 1:
            self.start_when_available.setChecked(True)
        elif int(project_core.scheduler.getIf_missed_run_upon_restart()) == 0:
            self.start_when_available.setChecked(False)

        if str(project_core.scheduler.getDurationType()) == '1':
            self.monthly.setChecked(True)
            self.monthClick()
            try:
                self.day_of_month.setValue(
                    int(project_core.scheduler.getRun_day_or_month()))
            except:
                self.Fixity.logger.LogException(Exception.message)
                return

        elif str(project_core.scheduler.getDurationType()) == '2':
            self.weekly.setChecked(True)
            self.weekClick()
            self.day_of_week.setCurrentIndex(
                int(project_core.scheduler.getRun_day_or_month()))

        elif str(project_core.scheduler.getDurationType()) == '3':
            self.daily.setChecked(True)
            self.dayClick()

        try:
            t = str(project_core.scheduler.getRunTime()).split(':')
        except:
            t = ['00', '00']

        self.timer.setTime(GUILibraries.QTime(int(t[0]), int(t[1])))
        self.timer.timeChanged.connect(self.changed)

        if last_run_label and last_run_label is not None and last_run_label != 'None':
            self.lastrun.setText("Last checked:\n" + last_run_label)
        else:
            self.lastrun.setText("Last checked:\n --")
        if new:
            self.old = new
        else:
            self.old = self.projects.currentItem()
        self.unsaved = False
Example #4
0
    def creatSchedulingOptions(self):
        self.scheduling_groupBox = GUILibraries.QGroupBox("Scheduling")
        self.monthly = GUILibraries.QRadioButton("Monthly")
        self.weekly = GUILibraries.QRadioButton("Weekly")
        self.daily = GUILibraries.QRadioButton("Daily")

        self.run_only_on_ac_power = GUILibraries.QCheckBox(
            "Run when on battery power")
        self.start_when_available = GUILibraries.QCheckBox(
            "If missed, run upon restart")
        self.email_only_when_something_changed = GUILibraries.QCheckBox(
            "Email only upon warning or failure")

        self.run_only_on_ac_power.clicked.connect(self.changed)
        self.start_when_available.clicked.connect(self.changed)
        self.email_only_when_something_changed.clicked.connect(self.changed)

        self.run_only_on_ac_power.setChecked(True)
        self.start_when_available.setChecked(True)
        self.email_only_when_something_changed.setChecked(True)

        self.monthly.clicked.connect(self.monthClick)
        self.weekly.clicked.connect(self.weekClick)
        self.daily.clicked.connect(self.dayClick)

        self.switchDebugger(True)
        self.scheduling_layout = GUILibraries.QVBoxLayout()

        self.scheduling_layout.addWidget(self.monthly)
        self.scheduling_layout.addWidget(self.weekly)
        self.scheduling_layout.addWidget(self.daily)
        self.scheduler_run_time = GUILibraries.QLabel("Scheduler Run Time: ")
        self.scheduling_layout.addWidget(self.scheduler_run_time)
        self.timer = GUILibraries.QTimeEdit(GUILibraries.QTime())

        self.timer.setDisplayFormat(self.Fixity.Configuration.getTimeFormat())
        self.scheduling_layout.addWidget(self.timer)

        self.scheduler_run_on = GUILibraries.QLabel("Scheduler Run On: ")
        self.scheduling_layout.addWidget(self.scheduler_run_on)
        self.day_of_week = GUILibraries.QComboBox()
        self.day_of_week.addItems(self.Fixity.Configuration.getWeekDays())
        self.day_of_week.activated.connect(self.changed)
        self.scheduling_layout.addWidget(self.day_of_week)
        self.day_of_week.hide()

        self.day_of_month = GUILibraries.QSpinBox()
        self.day_of_month.setMaximum(31)
        self.day_of_month.setMinimum(1)

        self.day_of_month.valueChanged.connect(self.changed)
        self.scheduling_layout.addWidget(self.day_of_month)
        self.day_of_month.hide()

        self.spacer = GUILibraries.QSpacerItem(125, 30)
        self.scheduling_layout.addItem(self.spacer)
        system_information = self.Fixity.Configuration.getWindowsInformation()

        if self.Fixity.Configuration.getOsType() == 'Windows' and (
                str(system_information['WindowsType']) == '7'
                or str(system_information['WindowsType']) == '10'
                or str(system_information['WindowsType']) == '8'):
            self.scheduling_layout.addWidget(self.run_only_on_ac_power)
            self.scheduling_layout.addWidget(self.start_when_available)
        self.scheduling_layout.addWidget(
            self.email_only_when_something_changed)

        self.lastrun = GUILibraries.QLabel("Last checked: ")
        self.scheduling_layout.addWidget(self.lastrun)
        self.scheduling_groupBox.setLayout(self.scheduling_layout)
        self.scheduling_groupBox.setFixedSize(260, 289)