Club Drupal

######## Dict of people who have an api-keys

#id: key

SUBMITERS = {'jenselme': 'b3ce5345b1444b66f05f6a143ffec6f401e8f17e', 'admin': 'a7630a1244be353424cc0f56a49657c3fa9dbcc6'}

MANAGER = 'admin' # Can post issues

#MANAGER = 'jenselme'

######## HTTP headers

######## Base URL of where to post the issues

URL_ISSUES = 'http://debian/redmine/issues'

#URL_POST_ISSUES = 'https://forge.centrale-marseille.fr/issues'

######## Issues list in redmine of a give project

URL_ISSUES_JSON = 'http://debian/redmine/projects/test/issues.json'

#URL_ISSUES_JSON = 'https://forge.centrale-marseille.fr/projects/clubdrupal/issues.json'

######## Project URL

URL_PROJECT = 'http://debian/redmine/projects/test'

#URL_PROJECT = 'https://forge.centrale-marseille.fr/projects/clubdrupal'

URL_REDMINE = 'http://debian/redmine'

#URL_REDMINE = 'http://forge.centrale-marseille.fr'

######## Issues location in drupal (node id in a csv file to be parsed)

LIST_TODO = 'http://debian/portail/liste-tache'

LIST_TODO_CSV = 'http://debian/portail/liste_tache_csv'

######## Base url of drupal

BASE_URL = 'http://debian/portail'

######## Various id

PROJECT_ID = 1

#PROJECT_ID = 30

USER_ID = {'ftorregrosa': 45, 'Ismaeil ABOULJAMAL': 44, 'iabouljamal': 44,\

           'Nono LiNux': 47, 'nlehuby': 47, 'gfranchi': 78, 'assos': 78, '82': 78, 'dgeo': 22,\

           'Jean': 48,'jfeutry': 48, 'adeprey': 49,'jpennec': 46, 'gt': 42, 'jenselme': 43,

           '1': 44, '176': 43, '123': 48, '114': 49,\

           '99': 46, '97': 45, '20': 47, '16': 42, '9': 22}

######## Dict to translate drupal's fields into redmine ids

#NB: sur le portail, on a les équivalences suivantes

# For drupal_version_field : 17 : drupal6, 18 : drupal7

###### Other

REGEXP_NAME = 'http://debian/portail/content/t%C3%A2che/(.*)'

# In order to complete the migration to Redmine, we need to preserve date

# and username. To do this, we need to fix the database.

use strict;

use warnings;

use DBI;

my $db		= 'redmine_default';

my $server	= 'localhost'; # Il est possible de mettre une adresse IP

my $user        = 'root';      # identifiant

my $passwd	= 'tata';

my $port	= '';

##### Create DB connection

my $dbh = DBI->connect( "DBI:mysql:database=$db;host=$server;port=$port", $user, $passwd, { RaiseError => 1, } ) or die "Connection impossible à la base de données $db !\n $! \n $@\n$DBI::errstr";

###### Initialisation of hashes needed to fix URL

open(my $fix_url_issues_csv, '<', 'fix_url_issues.csv') or die "Couldn't open fix_url_issues.csv";

my %name2iid = ();

my %nid2iid = ();

my %cid2iid = ();

my %cid2post_nb = ();

while (my $line = <$fix_url_issues_csv>)

  {

    chomp $line;

    my ($nid, $name, $iid) = split ",", $line;

    $name2iid{$name} = $iid;

    $nid2iid{$nid} = $iid;

  }

close $fix_url_issues_csv;

open(my $fix_url_comments_csv, '<', 'fix_url_comments.csv') or die "Couldn't open fix_url_comments.csv";

while (my $line = <$fix_url_comments_csv>)

  {

    chomp $line;

    my ($cid, $iid, $post_nb) = split ",", $line;

    $cid2iid{$cid} = $iid;

    $cid2post_nb{$cid} = $post_nb;

  }

close $fix_url_comments_csv;

###### Definition of functions

sub fix_issues_link {

    my $text = $_[0];

    # Find all links in text

    my @links = ($text =~ m/:http:\/\/assos\.centrale-marseille\.fr(?:\/|\/lessive\/)(?:content\/t%C3%A2che|node)\/(.*)/g);

    if ( @links )

    {

	foreach (@links)

	{

	    print $_ ."\n";

	    $text =~ s/"http:\/\/assos\.centrale-marseille\.fr(\/|\/lessive\/)(content\/t%C3%A2che|node)\/.*":http:\/\/assos\.centrale-marseille\.fr(\/|\/lessive\/)(content\/t%C3%A2che|node)\/$_/#$cid2iid{$_}#note-$cid2post_nb{$_}/g;

	}

    }

    return $text;

}

sub fix_comments_link {

    my $text = $_[0];

    # Find all links in text

    my @links = $text =~ m/"http:\/\/assos\.centrale-marseille\.fr(\/|\/lessive\/)comment\/.*"/g;

     # Foreach link, get comment cid.

    my @cids = ();

    if (@links)

    {

	foreach (@links)

	{

	    my $cid =~ s/"http:\/\/assos\.centrale-marseille\.fr(\/|\/lessive\/)comment\/(.*)#.*"/$1/g;

	    push @cids, $cid;

	}

	foreach (@cids)

	{

	    $text =~ s/"http:\/\/assos\.centrale-marseille\.fr(\/|\/lessive\/)comment\/$_#$_":http:\/\/assos\.centrale-marseille\.fr\/comment\/$_#$_/#$name2iid{$_}/g;

	}

    }

    return $text;

}

###### Update issues

my $sql_update_issue =<<"SQL";

UPDATE issues

  SET author_id = ?, created_on = ?

  WHERE  id = ?

SQL

my $sql_fix_links_issue =<<"SQL";

UPDATE issues

    SET description = ?

    WHERE id = ?

SQL

my $req_update_issue = $dbh->prepare($sql_update_issue);

my $req_fix_links_issue = $dbh->prepare($sql_fix_links_issue);

# Reading file

open(my $issues, '<issues.csv') or die "Couldn't open issues.txt\n";

while (my $line = <$issues>)

  {

    # Update author and date of creation

    chomp $line;

    my ($iid, $author_id, $created_on, $nid, $name) = split ",", $line;

    $req_update_issue->execute($author_id, $created_on, $iid);

    ## Fix links

    # issues

    my $select_description = "SELECT description FROM issues WHERE id = 1569";

    my ($description) = $dbh->selectrow_array($select_description);

    $description = fix_issues_link($description);

    die "stop";

    print $description . "\n";

#    print $links[0];

#    print $name2iid{$links[0]};

    # Comments

#    $description = fix_comments_link($description);

#    $req_fix_links_issue->execute($description, $iid);

  }

$req_update_issue->finish;

$req_fix_links_issue->finish;

###### Update journals

my $sql_get_id =<<"SQL";

SELECT id FROM journals WHERE journalized_id = ?

ORDER BY created_on ASC

SQL

my $sql_update_journals =<<"SQL";

UPDATE journals

SET created_on = ?, user_id = ?

WHERE id = ?

SQL

my $sql_updated_on =<<"SQL";

UPDATE issues SET updated_on = ?

WHERE id = ?

SQL

my $sql_fix_links_comment =<<"SQL";

UPDATE journals

    SET notes = ?

    WHERE id = ?

SQL

my $req_get_id = $dbh->prepare($sql_get_id);

my $req_update_journals = $dbh->prepare($sql_update_journals);

my $req_updated_on = $dbh->prepare($sql_updated_on);

my $req_fix_links_comment = $dbh->prepare($sql_fix_links_comment);

# Reading file.

open(my $comments, '<comments.csv') or die "Couldn't open comments.txt\n";

# We must remember current iid in order to fetch result or execute query: req_get_id return

# more than one value

my $current_iid = -1;

while (my $line = <$comments>)

  {

    chomp $line;

    my ($iid, $user_id, $created_on) = split ",", $line;

    # We get the id of the comment.

    if ($current_iid != $iid)

    {

	$current_iid = $iid;

	$req_get_id->execute($iid);

    }

    my ($id) = $req_get_id->fetchrow_array;

    # We do the update.

    $req_update_journals->execute($created_on, $user_id, $id);

    $req_updated_on->execute($created_on, $iid);

    ## Fix links.

    # issues

    my $select_notes = "SELECT notes FROM journals WHERE id = $id";

    my ($notes) = $dbh->selectrow_array($select_notes);

#    $notes = fix_issues_link($notes);

    # Comments

#    $notes = fix_comments_link($notes);

#    $req_fix_links_comment->execute($notes, $id);

  }

$req_get_id->finish;

$req_update_journals->finish;

$req_updated_on->finish;

####### Close the db connection.

$dbh->disconnect;

#!/usr/bin/env python3

"""This script can migrate issues from drupal to redmine.

It is design be launched with the -i option: most variables you may need for

debugging are easily accessible from interpreter (like HTTP status codes).

We make some assertion based on HTTP status code. Here are the codet you may

wish to know:

- 200: OK

- 201: Created

- 404: Not found

- 403: Forbidden

- 500: Internal error

Redmine gives you more intel in its response. Read them!

Pandoc is required to convert html syntax to textile syntax

import requests

import sys

import datetime

import os #we need system() to call pandoc

import re

import constantes as cst

######## Global variables

REGEXP_FIND_IMG = re.compile('!/.*!')

REGEXP_NAME_IMG = re.compile('!.*/(.*)!')

######## Common functions

def handle_image(txt):

    "Images are not posted automatically. There are only few of them.\

    We just format the text with the correct textile syntax and when we post them,\

    we will add comment and node id into a file. They should be attached to the\

    correct issue afterwards"

    has_image = False

    # In textile, images are between !

    images = REGEXP_FIND_IMG.findall(txt)

    print(images)

    if images:

        has_image = True

        for image in images:

            img_name = REGEXP_NAME_IMG.sub(r'!\1!', image)

            txt.replace(image, img_name)

    return txt, has_image

def html2textile(txt):

    "Convert a txt from html to textile using pandoc"

    # We remove line breaks and tabs, otherwise the conversion doesn't work properly

    # pandoc can only manipulates files

    # Cleaning temporary files

    os.remove('tmp.html')

    os.remove('tmp.textile')

    return handle_image(txt)

def egalise(string, length):

    "Make the length of string equals to length if shorter"

    if len(string) < length:

        return ' '*(length - len(string)) + string

        return string

def percentage(integer):

    "Converts integer into a string used to indicate the percentage of completion\

    of a command"

    string = str(integer)

    string = egalise(string, 3)

    string = 'Completion: ' + string + '%'

    return string + '\b'*len(string)

def print_progress(str):

    sys.stdout.write(str)

    sys.stdout.flush()

def format_date(timestamp):

    str_timestamp = float(timestamp)

    date = datetime.datetime.fromtimestamp(str_timestamp)

    return date.strftime('%Y-%m-%d %H:%M:%S')

######## Definition of classes

class Comment:

    """Represents a drupal comment

    """

    def __init__(self, cid, author, post_date, content, has_img):

        self._cid = cid # comment id in drupal

        self._author = author

        self._post_date = post_date

        self._content = content

        # json representation, to be posted in redmine

        self._update = {'issue': {'notes': self._content }}

        self._update_json = json.dumps(self._update)

        self._resp = None #will be used to store the put response

        self._has_img = has_img

    def post(self, url, headers, iid, post_nb):

        "Post the comment to url with headers (required for authentication)"

        self._resp = requests.put(url, headers=headers, data=self._update_json)

        assert self._resp.status_code == 200

        # We write iid,author_id,created_on in comments.csv

        with open('comments.csv', 'a', encoding='utf8') as comments_csv:

            comments_csv.write('{},{},{}\n'.\

                        format(iid, cst.USER_ID[self._author], self._post_date))

        with open('fix_url_comments.csv', 'a', encoding='utf8') as fix_url_csv:

            fix_url_csv.write('{},{},{}\n'.format(self._cid, iid, post_nb))

    @property

    def post_date(self):

        return self._post_date

    @property

    def resp(self):

        return self._resp

    @property

    def cid(self):

        return self._cid

    @property

    def has_img(self):

        return self._has_img

class Updates:

    """Represents all the comments of a task

    """

    def __init__(self, comments):

        self._comments = comments

    def sort(self):

        "Sort all the updates by date of creation"

        sorted_date = False

        while not sorted_date:

            sorted_date = True

            i = 0

            while i < len(self._comments) - 1:

                if self._comments[i].post_date > self._comments[i + 1].post_date:

                    self._comments[i], self._comments[i + 1] = self._comments[i + 1],\

                                                               self._comments[i]

                    sorted_date = False

                i += 1

    def __getitem__(self, index):

        return self._comments[index]

    def __len__(self):

        return len(self._comments)

    def __iter__(self):

        self.__i = -1

        return self

    def __next__(self):

        self.__i += 1

        if self.__i >= len(self._comments) or len(self._comments) == 0:

            raise StopIteration

        return self._comments[self.__i]

class Issue:

    """Represents a drupal issue

    """

    def __init__(self, nid, comments):

        self._nid = nid #node id

        self._iid = None #issue id, unknown until creation

        self._resp = None #will be used to store the response of requests.post

        self._comments = Updates(comments)

        self._comments.sort()

        self._issue = self.give_redmine_issue(nid) #the actual content, it's a dict

    def give_redmine_status_id(self, node):

        "Translate the drupal status field to an integer representing the\

        redmine status id"

        drupal_status = ''

        for elt in node['field_avancement']:

            if "Terminée" in elt:

                drupal_status = 'Fermée'

                break

            elif "Fermée" in elt:

                drupal_status = 'Rejetée'

                break

            elif "pause" in elt:

                drupal_status = 'En pause'

                del elt

                break

        if not drupal_status:

            drupal_status = 'En cours'

        return cst.STATUS[drupal_status]

    def give_redmine_issue(self, nid):

        "Uses the nid to find the node and converts its content to something\

        redmine can understand. Read examples for more intels"

        node_json = requests.get(cst.BASE_URL + '/node/{}.json'.format(nid)).text

        node = json.loads(node_json)

        issue = dict()

        issue['project_id'] = cst.PROJECT_ID

        issue['tracker_id'] = cst.TRACKER_ID

        issue['subject'] = node['title']

        issue['description'], self._has_img = html2textile(node['body']['value'])

        # We get the name of the node

        self._name = re.findall(cst.REGEXP_NAME, node['url'])[0]

        # field_prioritaecute can be empty. We then assume it is normal

        if node['field_prioritaecute']:

            issue['priority_id'] = cst.PRIORITY[node['field_prioritaecute']]

        else:

            issue['priority_id'] = cst.PRIORITY['3 - Moyenne']

        # field_avancement can be empty. We then assume it is to be started

        if node['field_avancement']:

            issue['done_ratio'] = cst.DONE_RATIO[node['field_avancement'][0]]

        else:

            issue['done_ratio'] = cst.DONE_RATIO['À commencer']

        # Status id = open, fix, closed…

        issue['status_id'] = self.give_redmine_status_id(node)

        issue['fixed_version_id'] = cst.DRUPAL_VERSION[node['taxonomy_vocabulary_8']['id']]

        issue['created'] = format_date(node['created'])

        issue['author_id'] = node['author']['id']

        # Do we have attached files?

        if node['field_fichier']:

            self._has_files = True

        else:

            self._has_files = False

        return issue

    def post(self, url, headers):

        "Post the comment to url with headers (required for authentication)"

        issue = {'issue': self._issue}

        data = json.dumps(issue)

        self._resp = requests.post(url, headers=headers, data=data)

        assert self._resp.status_code == 201

        resp_json = json.loads(self._resp.text)

        self._iid = resp_json['issue']['id']

        # We write iid,author_id,created_on in issues.csv

        with open('issues.csv', 'a', encoding='utf8') as issues_csv:

            author_id = self._issue['author_id']

            redmine_author_id = cst.USER_ID[author_id]

            created_on = self._issue['created']

            issues_csv.write('{},{},{}\n'.\

                             format(self._iid, redmine_author_id, created_on))

        with open('fix_url_issues.csv', 'a') as fix_url:

            fix_url.write('{},{},{}\n'.format(self._nid, self._name, self._iid))

        # We post comments

        nb_comments = len(self._comments)

        i = 0

        for comment in self._comments:

            i += 1

            put_url =  cst.URL_ISSUES + '/{}.json'.format(self._iid)

            comment.post(put_url, headers, self._iid, i)

            print_progress(percentage(i//nb_comments*100))

        # We take care of images and files

        self.handle_image()

        self.handle_files()

    def handle_files(self):

        if self._has_files:

            with open('has_files.txt', 'a', encoding='utf8') as has_files_file:

                has_files_file.write('{}\n'.format(self._nid))

    def handle_image(self):

        for comment in self._comments:

            self._has_img = comment.has_img or self._has_img

        if self._has_img:

            with open('has_img.txt', 'a', encoding='utf8') as has_img_file:

                has_img_file.write('{}\n'.format(self._nid))

    @property

    def resp(self):

        return self._resp

    @property

    def comments_resp(self):

        resps = dict()

        for comment in self._comments:

            resps[comment.cid] = comment.resp

        return resps

class Laundry:

    """Contains all issues and has methods to perform the migration

    Iteration of this object traverses all issues.

    You can access any issue with the container notation

    """

    def __init__(self, url, test=True):

        self._issues = self.give_issues(url, test)

    def give_issues(self, url, test):

        "Returns a list of all issues"

        issues = []

        r = requests.get(url)

        assert r.status_code == 200

        # 1st element is 'Nid', and last is ''

        nids = r.text.split('\r\n')[1:-1]

        # for test, we only use 3 issues (faster)

        if test:

            nids = nids[:3]

        self.nb_task = len(nids)

        i = 0

        for nid in nids:

            i += 1

            comments = self.give_comments(nid)

            print('Fetching issue no {} on {}'.format(i, self.nb_task))

            issues.append(Issue(nid, comments))

        return issues

    def give_comments(self, nid):

        "Returns the list of all comments of a node"

        cids, comments_json = self.give_comments_json(nid)

        comments = []

        i = 0

        nb_comments = len(comments_json)

        for comment_json in comments_json:

            author = comment_json['name']

            post_date = format_date(comment_json['created'])

            content, has_img = html2textile(comment_json['comment_body']['value'])

            comments.append(Comment(cids[comments_json.index(comment_json)], author, post_date, content, has_img))

            i += 1

            print_progress(percentage(i//nb_comments*100))

        return comments

    def give_comments_json(self, nid):

        "Get the raw json version of the drupal comment"

        cids = self.give_comments_ids(nid)

        comments = list()

        for cid in cids:

            comment = requests.get(cst.BASE_URL + '/comment/' + cid + '.json')

            comments.append(json.loads(comment.text))

        return cids, comments

    def give_comments_ids(self, nid):

        "Get the cid (comnments id) for a node"

        headers = cst.Headers_GET

        headers['X-Redmine-API-Key'] = cst.SUBMITERS[cst.MANAGER]

        r = requests.get(cst.BASE_URL + '/entity_json/node/{}'.format(nid), headers=headers)

        page_json = json.loads(r.text)

        comments_json = page_json['comments']

        #If the issue has no comment, comments_json is a list, not a dict

        if comments_json:

            comments = list(comments_json.keys())

            return comments

        else:

            return list()

    def __iter__(self):

        self.__i = -1

        return self

    def __next__(self):

        self.__i += 1

        if self.__i >= len(self._issues):

            raise StopIteration

        return self._issues[self.__i]

    def __getitem__(self, index):

        return self._issues[index]

    def __len__(self):

        return len(self._issues)

class Redmine:

    """Main class.

    Allows the interaction with the program

    You can access any issue with the container notation.

    """

    def __init__(self, test=True):

        self.reset()

        self._test = test

    def reset(self):

        "Go to initial stage. All attributes are set to None"

        self._laundry = None

        self._headers = None

        self._headers_get = None

    def init(self, issues_file='issues.csv', x_redmine_api_key=cst.SUBMITERS[cst.MANAGER]):

        "Initialize the attribute for post uses"

        self._headers = cst.Headers

        self._headers['X-Redmine-API-Key'] = x_redmine_api_key

        self._laundry = Laundry(cst.LIST_TODO_CSV, self._test)

    def post(self, post_url=cst.URL_ISSUES_JSON):

        "Post all issues"

        nb_issues = len(self._laundry)

        i = 0

        for issue in self._laundry:

            i += 1

            print('Posting issues {} on {}'.format(i, nb_issues))

            issue.post(post_url, self._headers)

    def sweep(self):

        "Clean the redmine project of all issues."

        print('You are about to delete all issues on your redmine project.')

        ok = input('Do you wish to continue? (yes/no): ')

        if ok == 'yes':

            # Get the right headers

            self._headers_get = cst.Headers_GET

            self._headers_get['X-Redmine-API-Key'] = cst.SUBMITERS[cst.MANAGER]

            # Redmine give at maximum 100 issues. We may need to do it many times

            pass_number = 1

            while True:

                r = requests.get(cst.URL_ISSUES_JSON + '?status_id=*&limit=100',\

                                 headers=cst.Headers_GET)

                assert r.status_code == 200

                if not json.loads(r.text)['issues']: # There are no more issues to sweep

                    break

                print('Pass {}'.format(pass_number))

                taches_json = json.loads(r.text)['issues']

                # Print a nice completion percentage

                sys.stdout.flush()

                compt = 0

                print_progress(percentage(compt//len(taches_json)*100))

                for tache in taches_json:

                    tid = tache['id']

                    r = requests.delete(cst.URL_REDMINE + '/issues/{}.json'.format(tid),\

                                        headers=cst.Headers_GET)

                    compt += 1

                    print_progress(percentage(int(compt/len(taches_json)*100)))

                sys.stdout.write("\n")

                pass_number += 1

        else:

            print('Wise decision')

    def __getitem__(self, index):

        if self._laundry:

            return self._laundry[index]

        else:

            raise IndexError('Index out of range')

######## Main program

if __name__ == "__main__":

    redmine = Redmine(test=False)

    redmine.init()

    redmine.post()

* About to connect() to localhost port 80 (#0)

*   Trying ::1...

* connected

* Connected to localhost (::1) port 80 (#0)

> POST /redmine/issues.json HTTP/1.1

> User-Agent: curl/7.26.0

> Host: localhost

> Accept: */*

> Content-Type: application/json

> X-Redmine-API-Key: a7630a1244be353424cc0f56a49657c3fa9dbcc6

> Content-Length: 255

> 

* upload completely sent off: 255 out of 255 bytes

* additional stuff not fine transfer.c:1037: 0 0

* HTTP 1.1 or later with persistent connection, pipelining supported

< HTTP/1.1 201 Created

< Date: Tue, 02 Jul 2013 10:18:03 GMT

< Server: Apache/2.2.22 (Debian)

< X-Powered-By: Phusion Passenger (mod_rails/mod_rack) 3.0.13

< Cache-Control: no-cache

< X-Runtime: 173

< Set-Cookie: autologin=; path=/; expires=Thu, 01-Jan-1970 00:00:00 GMT

< Set-Cookie: _redmine_default=BAh7BjoPc2Vzc2lvbl9pZCIlOWMyMDE3ZjUyOWMwYzFhNzkzODk3NzkwMzcxMDI0Njg%3D--53d46d1fb4e9684381a35ad0951b669869dde966; path=/redmine; HttpOnly

< Location: http://localhost/redmine/issues/7

< Content-Length: 433

< Status: 201

< Content-Type: application/json; charset=utf-8

< 

* Connection #0 to host localhost left intact

{"issue":{"status":{"name":"New","id":1},"done_ratio":100,"subject":"tache 8","updated_on":"2013/07/02 11:18:03 +0100","tracker":{"name":"Feature","id":2},"spent_hours":0.0,"description":"J'\u00e9cris plein de chose\r\nPour ma premi\u00e8re tache","start_date":"2013/07/02","author":{"name":"Redmine Admin","id":1},"created_on":"2013/07/02 11:18:03 +0100","project":{"name":"test","id":1},"id":7,"priority":{"name":"Urgent","id":6}}}* Closing connection #0

* About to connect() to localhost port 80 (#0)

*   Trying ::1...

* connected

* Connected to localhost (::1) port 80 (#0)

> PUT /redmine/issues/6.json HTTP/1.1

> User-Agent: curl/7.26.0

> Host: localhost

> Accept: */*

> Content-Type: application/json

> X-Redmine-API-Key: a7630a1244be353424cc0f56a49657c3fa9dbcc6

> Content-Length: 52

> 

* upload completely sent off: 52 out of 52 bytes

* additional stuff not fine transfer.c:1037: 0 0

* HTTP 1.1 or later with persistent connection, pipelining supported

< HTTP/1.1 200 OK

< Date: Tue, 02 Jul 2013 10:15:18 GMT

< Server: Apache/2.2.22 (Debian)

< X-Powered-By: Phusion Passenger (mod_rails/mod_rack) 3.0.13

< Cache-Control: no-cache

< X-Runtime: 133

< Set-Cookie: autologin=; path=/; expires=Thu, 01-Jan-1970 00:00:00 GMT

< Set-Cookie: _redmine_default=BAh7BzoPc2Vzc2lvbl9pZCIlOTFmNDkxMzg3MTZmNDUzYzk3NDc4NTliNjYzZmZiZDIiCmZsYXNoSUM6J0FjdGlvbkNvbnRyb2xsZXI6OkZsYXNoOjpGbGFzaEhhc2h7BjoLbm90aWNlIipNaXNlIMOgIGpvdXIgZWZmZWN0dcOpZSBhdmVjIHN1Y2PDqHMuBjoKQHVzZWR7BjsHRg%3D%3D--252700c9688855c080f30d577da1cb9e60ebc53b; path=/redmine; HttpOnly

< Content-Length: 1

< Status: 200

< Content-Type: application/json; charset=utf-8

< 

* Connection #0 to host localhost left intact

 * Closing connection #0

### Ce script a été écrit afin de supprimer les préfixes des tables des bases données.

### Ces préfixes étaient indispensables quand tous les sites étaient dans une même base de données.

use strict;

use warnings;

use DBI;

my $bd		= $ARGV[0];

my $serveur	= 'localhost'; # Il est possible de mettre une adresse IP

my $identifiant = 'root';      # identifiant

my $motdepasse	= 'tata';

my $port	= '';

my ($prefix) = $ARGV[1];

my $dbh = DBI->connect( "DBI:mysql:database=$bd;host=$serveur;port=$port", $identifiant, $motdepasse, { RaiseError => 1, } ) or die "Connection impossible à la base de données $bd !\n $! \n $@\n$DBI::errstr";

my @table_names = $dbh->tables;

foreach my $table(@table_names)

{

    #print $table =~ m/$prefix/;

    #print $table . "\n";

    if( $table =~ m/^`$bd`\.`$prefix/ )

    {

	my ($new_name) = ( $table =~ m/$prefix(.*)`/ );

	my $new_table = "`$bd`.`$new_name`";

	print $new_name . "\n";

	print $new_table . "\n";

	$dbh->do('DROP TABLE IF EXISTS ' . $new_name);

	$dbh->do('RENAME TABLE ' . $table . ' TO ' . $new_name) or die 'Ne peut exécuter la requête';

    }

}

$dbh->disconnect();