forked from openlp/openlp
266 lines
13 KiB
Python
266 lines
13 KiB
Python
# -*- coding: utf-8 -*-
|
|
# vim: autoindent shiftwidth=4 expandtab textwidth=120 tabstop=4 softtabstop=4
|
|
|
|
###############################################################################
|
|
# OpenLP - Open Source Lyrics Projection #
|
|
# --------------------------------------------------------------------------- #
|
|
# Copyright (c) 2008-2018 OpenLP Developers #
|
|
# --------------------------------------------------------------------------- #
|
|
# This program is free software; you can redistribute it and/or modify it #
|
|
# under the terms of the GNU General Public License as published by the Free #
|
|
# Software Foundation; version 2 of the License. #
|
|
# #
|
|
# This program is distributed in the hope that it will be useful, but WITHOUT #
|
|
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or #
|
|
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for #
|
|
# more details. #
|
|
# #
|
|
# You should have received a copy of the GNU General Public License along #
|
|
# with this program; if not, write to the Free Software Foundation, Inc., 59 #
|
|
# Temple Place, Suite 330, Boston, MA 02111-1307 USA #
|
|
###############################################################################
|
|
"""
|
|
The :mod:`opspro` module provides the functionality for importing
|
|
a OPS Pro database into the OpenLP database.
|
|
"""
|
|
|
|
# WARNING: See https://docs.python.org/2/library/sqlite3.html for value substitution
|
|
# in SQL statements
|
|
|
|
import logging
|
|
import re
|
|
import struct
|
|
|
|
import pyodbc
|
|
|
|
from openlp.core.common.i18n import translate
|
|
from openlp.plugins.songs.lib.importers.songimport import SongImport
|
|
|
|
log = logging.getLogger(__name__)
|
|
|
|
|
|
class OPSProImport(SongImport):
|
|
"""
|
|
The :class:`OPSProImport` class provides the ability to import the
|
|
WorshipCenter Pro Access Database
|
|
"""
|
|
def __init__(self, manager, **kwargs):
|
|
"""
|
|
Initialise the WorshipCenter Pro importer.
|
|
"""
|
|
super(OPSProImport, self).__init__(manager, **kwargs)
|
|
|
|
def do_import(self):
|
|
"""
|
|
Receive a single file to import.
|
|
"""
|
|
password = self.extract_mdb_password()
|
|
try:
|
|
conn = pyodbc.connect('DRIVER={{Microsoft Access Driver (*.mdb)}};DBQ={source};'
|
|
'PWD={password}'.format(source=self.import_source, password=password))
|
|
except (pyodbc.DatabaseError, pyodbc.IntegrityError, pyodbc.InternalError, pyodbc.OperationalError) as e:
|
|
log.warning('Unable to connect the OPS Pro database {source}. {error}'.format(source=self.import_source,
|
|
error=str(e)))
|
|
# Unfortunately no specific exception type
|
|
self.log_error(self.import_source, translate('SongsPlugin.OPSProImport',
|
|
'Unable to connect the OPS Pro database.'))
|
|
return
|
|
cursor = conn.cursor()
|
|
cursor.execute('SELECT Song.ID, SongNumber, SongBookName, Title, CopyrightText, Version, Origin FROM Song '
|
|
'LEFT JOIN SongBook ON Song.SongBookID = SongBook.ID ORDER BY Title')
|
|
songs = cursor.fetchall()
|
|
self.import_wizard.progress_bar.setMaximum(len(songs))
|
|
for song in songs:
|
|
if self.stop_import_flag:
|
|
break
|
|
# Type means: 0=Original, 1=Projection, 2=Own
|
|
cursor.execute('SELECT Lyrics, Type, IsDualLanguage FROM Lyrics WHERE SongID = ? AND Type < 2 '
|
|
'ORDER BY Type DESC', float(song.ID))
|
|
lyrics = cursor.fetchone()
|
|
cursor.execute('SELECT CategoryName FROM Category INNER JOIN SongCategory '
|
|
'ON Category.ID = SongCategory.CategoryID WHERE SongCategory.SongID = ? '
|
|
'ORDER BY CategoryName', float(song.ID))
|
|
topics = cursor.fetchall()
|
|
try:
|
|
self.process_song(song, lyrics, topics)
|
|
except Exception as e:
|
|
self.log_error(self.import_source,
|
|
translate('SongsPlugin.OPSProImport',
|
|
'"{title}" could not be imported. {error}').format(title=song.Title, error=e))
|
|
|
|
def process_song(self, song, lyrics, topics):
|
|
"""
|
|
Create the song, i.e. title, verse etc.
|
|
|
|
The OPS Pro format is a fairly simple text format using tags and anchors/labels. Linebreaks are \r\n.
|
|
Double linebreaks are slide dividers. OPS Pro support dual language using tags.
|
|
Tags are in [], see the liste below:
|
|
[join] are used to separate verses that should be keept on the same slide.
|
|
[split] or [splits] can be used to split a verse over several slides, while still being the same verse
|
|
Dual language tags:
|
|
[trans off] or [vertaal uit] turns dual language mode off for the following text
|
|
[trans on] or [vertaal aan] turns dual language mode on for the following text
|
|
[taal a] means the following lines are language a
|
|
[taal b] means the following lines are language b
|
|
"""
|
|
self.set_defaults()
|
|
self.title = song.Title
|
|
if song.CopyrightText:
|
|
for line in song.CopyrightText.splitlines():
|
|
if line.startswith('©') or line.lower().startswith('copyright'):
|
|
self.add_copyright(line)
|
|
else:
|
|
self.parse_author(line)
|
|
if song.Origin:
|
|
self.comments = song.Origin
|
|
if song.SongBookName:
|
|
self.song_book_name = song.SongBookName
|
|
if song.SongNumber:
|
|
self.song_number = song.SongNumber
|
|
for topic in topics:
|
|
self.topics.append(topic.CategoryName)
|
|
# Try to split lyrics based on various rules
|
|
if lyrics:
|
|
lyrics_text = lyrics.Lyrics
|
|
verses = re.split(r'\r\n\s*?\r\n', lyrics_text)
|
|
verse_tag_defs = {}
|
|
verse_tag_texts = {}
|
|
for verse_text in verses:
|
|
if verse_text.strip() == '':
|
|
continue
|
|
verse_def = 'v'
|
|
# Detect verse number
|
|
verse_number = re.match(r'^(\d+)\r\n', verse_text)
|
|
if verse_number:
|
|
verse_text = re.sub(r'^\d+\r\n', '', verse_text)
|
|
verse_def = 'v' + verse_number.group(1)
|
|
# Detect verse tags
|
|
elif re.match(r'^.+?\:\r\n', verse_text):
|
|
tag_match = re.match(r'^(.+?)\:\r\n(.*)', verse_text, flags=re.DOTALL)
|
|
tag = tag_match.group(1).lower()
|
|
tag = tag.split(' ')[0]
|
|
verse_text = tag_match.group(2)
|
|
if 'refrein' in tag or 'chorus' in tag:
|
|
verse_def = 'c'
|
|
elif 'bridge' in tag:
|
|
verse_def = 'b'
|
|
verse_tag_defs[tag] = verse_def
|
|
verse_tag_texts[tag] = verse_text
|
|
# Detect tag reference
|
|
elif re.match(r'^\(.*?\)$', verse_text):
|
|
tag_match = re.match(r'^\((.*?)\)$', verse_text)
|
|
tag = tag_match.group(1).lower()
|
|
if tag in verse_tag_defs:
|
|
verse_text = verse_tag_texts[tag]
|
|
verse_def = verse_tag_defs[tag]
|
|
# Detect end tag
|
|
elif re.match(r'^\[slot\]\r\n', verse_text, re.IGNORECASE):
|
|
verse_def = 'e'
|
|
verse_text = re.sub(r'^\[slot\]\r\n', '', verse_text, flags=re.IGNORECASE)
|
|
# Replace the join tag with line breaks
|
|
verse_text = verse_text.replace('[join]', '')
|
|
# Replace the split tag with line breaks and an optional split
|
|
verse_text = re.sub(r'\[splits?\]', '\r\n[---]', verse_text)
|
|
# Handle translations
|
|
if lyrics.IsDualLanguage:
|
|
verse_text = self.handle_translation(verse_text)
|
|
# Remove comments
|
|
verse_text = re.sub(r'\(.*?\)\r\n', '', verse_text, flags=re.IGNORECASE)
|
|
self.add_verse(verse_text, verse_def)
|
|
self.finish()
|
|
|
|
def handle_translation(self, verse_text):
|
|
"""
|
|
Replace OPS Pro translation tags with a {translation} tag
|
|
|
|
:param verse_text: the verse text
|
|
:return: the verse text with replaced tags
|
|
"""
|
|
language = None
|
|
translation = True
|
|
translation_verse_text = ''
|
|
start_tag = '{translation}'
|
|
end_tag = '{/translation}'
|
|
verse_text_lines = verse_text.splitlines()
|
|
idx = 0
|
|
while idx < len(verse_text_lines):
|
|
# Detect if translation is turned on or off
|
|
if verse_text_lines[idx] in ['[trans off]', '[vertaal uit]']:
|
|
translation = False
|
|
idx += 1
|
|
elif verse_text_lines[idx] in ['[trans on]', '[vertaal aan]']:
|
|
translation = True
|
|
idx += 1
|
|
elif verse_text_lines[idx] == '[taal a]':
|
|
language = 'a'
|
|
idx += 1
|
|
elif verse_text_lines[idx] == '[taal b]':
|
|
language = 'b'
|
|
idx += 1
|
|
if not idx < len(verse_text_lines):
|
|
break
|
|
# Handle the text based on whether translation is off or on
|
|
if language:
|
|
if language == 'b':
|
|
translation_verse_text += start_tag
|
|
while idx < len(verse_text_lines) and not verse_text_lines[idx].startswith('['):
|
|
translation_verse_text += verse_text_lines[idx] + '\r\n'
|
|
idx += 1
|
|
if language == 'b':
|
|
translation_verse_text += end_tag
|
|
language = None
|
|
elif translation:
|
|
translation_verse_text += verse_text_lines[idx] + '\r\n'
|
|
idx += 1
|
|
if idx < len(verse_text_lines) and not verse_text_lines[idx].startswith('['):
|
|
translation_verse_text += start_tag + verse_text_lines[idx] + end_tag + '\r\n'
|
|
idx += 1
|
|
else:
|
|
translation_verse_text += verse_text_lines[idx] + '\r\n'
|
|
idx += 1
|
|
while idx < len(verse_text_lines) and not verse_text_lines[idx].startswith('['):
|
|
translation_verse_text += verse_text_lines[idx] + '\r\n'
|
|
idx += 1
|
|
return translation_verse_text
|
|
|
|
def extract_mdb_password(self):
|
|
"""
|
|
Extract password from mdb. Based on code from
|
|
http://tutorialsto.com/database/access/crack-access-*.-mdb-all-current-versions-of-the-password.html
|
|
"""
|
|
# The definition of 13 bytes as the source XOR Access2000. Encrypted with the corresponding signs are 0x13
|
|
xor_pattern_2k = (0xa1, 0xec, 0x7a, 0x9c, 0xe1, 0x28, 0x34, 0x8a, 0x73, 0x7b, 0xd2, 0xdf, 0x50)
|
|
# Access97 XOR of the source
|
|
xor_pattern_97 = (0x86, 0xfb, 0xec, 0x37, 0x5d, 0x44, 0x9c, 0xfa, 0xc6, 0x5e, 0x28, 0xe6, 0x13)
|
|
with self.import_source.open('rb') as mdb_file:
|
|
mdb_file.seek(0x14)
|
|
version = struct.unpack('B', mdb_file.read(1))[0]
|
|
# Get encrypted logo
|
|
mdb_file.seek(0x62)
|
|
EncrypFlag = struct.unpack('B', mdb_file.read(1))[0]
|
|
# Get encrypted password
|
|
mdb_file.seek(0x42)
|
|
encrypted_password = mdb_file.read(26)
|
|
# "Decrypt" the password based on the version
|
|
decrypted_password = ''
|
|
if version < 0x01:
|
|
# Access 97
|
|
if int(encrypted_password[0] ^ xor_pattern_97[0]) == 0:
|
|
# No password
|
|
decrypted_password = ''
|
|
else:
|
|
for j in range(0, 12):
|
|
decrypted_password = decrypted_password + chr(encrypted_password[j] ^ xor_pattern_97[j])
|
|
else:
|
|
# Access 2000 or 2002
|
|
for j in range(0, 12):
|
|
if j % 2 == 0:
|
|
# Every byte with a different sign or encrypt. Encryption signs here for the 0x13
|
|
t1 = chr(0x13 ^ EncrypFlag ^ encrypted_password[j * 2] ^ xor_pattern_2k[j])
|
|
else:
|
|
t1 = chr(encrypted_password[j * 2] ^ xor_pattern_2k[j])
|
|
decrypted_password = decrypted_password + t1
|
|
if ord(decrypted_password[1]) < 0x20 or ord(decrypted_password[1]) > 0x7e:
|
|
decrypted_password = ''
|
|
return decrypted_password
|