├── .gitignore
├── Csv_import.php
├── README.md
├── doc
    └── readme.txt
├── lang
    ├── strings_dutch.txt
    ├── strings_english.txt
    ├── strings_french.txt
    ├── strings_german.txt
    └── strings_italian.txt
└── pages
    ├── config.php
    ├── config_edit.php
    ├── import_issues.php
    ├── import_issues_inc.php
    ├── import_issues_page_col_set.php
    └── import_issues_page_init.php


/.gitignore:
--------------------------------------------------------------------------------
1 | /.idea/
2 | 


--------------------------------------------------------------------------------
/Csv_import.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | class Csv_importPlugin extends MantisPlugin
 3 | {
 4 | 	function register() {
 5 | 		$this->name = plugin_lang_get( 'title' );
 6 | 		$this->description = plugin_lang_get( 'description' );
 7 | 		$this->version = '2.0.0';
 8 | 		$this->requires = array( 'MantisCore' => '2.0.0' );
 9 | 		$this->author = 'Bug 4220 Team';
10 | 		$this->contact = 'https://github.com/mantisbt-plugins/csv-import/';
11 | 		$this->url = 'https://github.com/mantisbt-plugins/csv-import/';
12 | 		$this->page = 'config';
13 | 	}
14 | 
15 | 	function config() {
16 | 		return array(
17 | 			'import_issues_threshold'	=> MANAGER ,
18 | 			);
19 | 	}
20 | 
21 | 	function hooks() {
22 | 		return array(
23 | 			'EVENT_MENU_MANAGE' => 'csv_import_menu',
24 | 		);
25 | 	}
26 | 
27 | 	function csv_import_menu() {
28 | 		return array(
29 | 			'<a href="' . plugin_page( 'import_issues_page_init' ) . '">' . plugin_lang_get( 'manage_issues_link' ) . '</a>',
30 | 		);
31 | 	}
32 | }
33 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | CSV Issues Importer
 2 | ===================
 3 | 
 4 | A plugin that imports issues from CSV files.
 5 | 
 6 | Install
 7 | -------
 8 | 
 9 | - Download or clone the repository and place it under the MantisBT plugins folder.
10 |   Make sure you get the correct version for your MantisBT (See [Compatibility](#compatibility) below). 
11 | - Rename the folder to Csv_import (case sensitive)
12 | - Go to Manage - Manage Plugins and install the plugin.
13 | - Go to Manage - Import Issues
14 | 
15 | Features
16 | --------
17 | 
18 | The plugin supports:
19 | 
20 | - auto-creating users as part of import.
21 | - auto-creating categories as part of import.
22 | - custom fields importing.
23 | - importing as new issues.
24 | - updating issues after matching by ids.
25 | - updating issues after matching by selected fields assuming a single match.
26 | 
27 | A few hints about usability
28 | ---------------------------
29 | 
30 | - Have a separate csv file per project.
31 | - Switch to the project before importing.
32 | - If the goal is to add the rows from csv, then make sure to map Id fields (if in CSV) to be ignored.
33 | - If the id is supplied, then issues with be updated based on data from the csv after matching by id.
34 | - Users that are auto-created will 
35 |   - be disabled 
36 |   - have random passwords, 
37 |   - have email as `username@localhost`.
38 | 
39 | Compatibility
40 | -------------
41 | 
42 | Depending on which version of MantisBT you are using, please make sure to
43 | get the appropriate version of the source code.
44 | Use [release tags](https://github.com/mantisbt-plugins/csv-import/releases),
45 | or the relevant branch in the Plugin's GitHub repository, as per the table below:
46 | 
47 | MantisBT version | Plugin version | Branch
48 | :---:|:---:|---
49 | 2.x   | v2.x | [master](https://github.com/mantisbt-plugins/csv-import/archive/master.zip)
50 | 1.3.x | v1.5.x | [master-1.3.x](https://github.com/mantisbt-plugins/csv-import/archive/master-1.3.x.zip)
51 | 1.2.x | v1.4.1 | [master-1.2.x](https://github.com/mantisbt-plugins/csv-import/archive/master-1.2.x.zip)
52 | 
53 | Support
54 | -------
55 | 
56 | Report issue in the [MantisBT bug tracker](https://mantisbt.org/bugs)
57 | under the **Plugin - CsvImport** project.
58 | 
59 | However, please note that this plugin is not actively supported by its original authors.
60 |  


--------------------------------------------------------------------------------
/doc/readme.txt:
--------------------------------------------------------------------------------
  1 | Mantis Issue Importer
  2 | =====================
  3 | 
  4 | History:
  5 | ________
  6 | 
  7 | Version | Author                 | Action
  8 | --------------------------------------------------------------------------------------
  9 |  1.3.0b | lionheart33806         | Added "primay key" feature
 10 |         | (sorry for my english) | Bug fixes (updates were impossible, sometimes first column was ignored)
 11 |         |                        | Removed "alternative import" feature (original import is RFC compliant !!)
 12 |         |                        | Column detection is less strict
 13 |         |                        | Some HTML and PHP format corrections
 14 |         |                        | Corrected some errors display
 15 |  1.2.0  | lionheart33806         | import_issues_page.php splitted to become
 16 |         |                        |  import_issues_page_init.php and import_issues_page_col_set.php
 17 |         |                        | Can create unknown categories
 18 |         |                        | Little JS to use tab as separator
 19 |  1.1.5  | lionheart33806         | Code closer of mantis coding conventions
 20 |         |                        | "all projects" categories reusable
 21 |         |                        | Can import "submitted date" with DD/MM/YYYY format
 22 |         |                        | Checkbox for alternative import
 23 |         |                        |     because of double quotes
 24 |         |                        | Added helper_begin_long_process() for very long imports
 25 |  1.1.4  | Stéphane Veyret        | Add german version of jojow 
 26 |  1.1.3  | Stéphane Veyret        | Make the strings "private" with plugin_lang_get
 27 |         |                        | Add french version
 28 |  1.1.2  | Udo Sommer and Cas Nuy | Transformed into plugin
 29 |  1.0    | Stéphane Veyret        | Improvements
 30 | (old)   | ave                    | Importer creation
 31 | 
 32 | 
 33 | Known Issues:
 34 | _____________
 35 | 
 36 | * Please, see https://github.com/lionheart33806/Csv-import-4-MantisBT/issues
 37 | 
 38 | 
 39 | Licence:
 40 | ________
 41 | 
 42 | The licence of CSV Import remains untouched, means GPL,
 43 | as stated in THE GPL.
 44 | 
 45 | 
 46 | Installation:
 47 | _____________
 48 | 
 49 | Create a "Csv_import" directory in "plugins" directory of mantis.
 50 | Extract all the files in "Csv_import".
 51 | 
 52 | In "Manage" module, you should find "Import CSV file".
 53 | 
 54 | NB : "Csv_import" is case sensitive.
 55 | 
 56 | 
 57 | Function:
 58 | _________
 59 | 
 60 | Imports/update one or more issues from a CSV text file into the current project of Mantis.
 61 | 
 62 | 
 63 | Requirements:
 64 | _____________
 65 | 
 66 | Made for and tested against Mantis version 1.2.0
 67 | 
 68 | 
 69 | Usage:
 70 | ______
 71 | 
 72 | Take care that this importing functionality can make a mess in your database. It is recommanded that you make
 73 | a backup of your database before importing.
 74 | 
 75 | Dates can be given with timestamp, "European" (d-m-y) or American (m/d/y) format.
 76 | 
 77 | 1. In the "Manage" menu, select "Import CSV file".
 78 | 
 79 | 2. Select the file to import. Your file must be in a correct CSV format (see above), and must only contain
 80 |    importable columns. The first line of the file can be a title line. In that case do not forget to
 81 |    select "Skip first line".
 82 | 
 83 | 3. Select the "Import file" button.
 84 | 
 85 | 4. The importer will try to recognize if the file use standard column names, or the name as given in
 86 | 	your current language.
 87 | 	If the importer did not detect your columns automatically, select them. Please, always verify the columns.
 88 | 	If you import many times from an another bug tracker, you should previously create a custom field which will contain
 89 | 	the other bug tracker bug id. Then, check in "Primay key" column the line corresponding  to the custom field.
 90 | 
 91 | 	If you define a column as a mantis ID, "primary key" checkboxes will be ignored.
 92 | 
 93 | 5. Select the "Import" button.
 94 | 
 95 | 6. Review the results to ensure they are as expected.
 96 | 
 97 | 
 98 | About CSV format:
 99 | _________________
100 | 
101 | Be sure your file is RFC compliant
102 | Look at :
103 | http://tools.ietf.org/html/rfc4180
104 | or
105 | http://en.wikipedia.org/wiki/Comma-separated_values
106 | 


--------------------------------------------------------------------------------
/lang/strings_dutch.txt:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | # Custom strings for english language
 4 | $s_plugin_Csv_import_title = 'Mantis CSV Importeerder';
 5 | $s_plugin_Csv_import_description = 'Importeer CSV bestanden als Mantis meldingen';
 6 | $s_plugin_Csv_import_config = 'Configuratie';
 7 | $s_plugin_Csv_import_update_config = 'Wijzig configuratie';
 8 | $s_plugin_Csv_import_file_format_col_spacer = 'CSV kolom scheidingsteken';
 9 | $s_plugin_Csv_import_skip_blank_lines = 'Sla lege regels over';
10 | $s_plugin_Csv_import_skip_blank_columns = 'Sla alle kolommen na een lege kolomtitel over.';
11 | $s_plugin_Csv_import_create_unknown_cats = 'Creëer onbekende categorieën';
12 | $s_plugin_Csv_import_tab_csv_separator = 'Gebruik tab';
13 | $s_plugin_Csv_import_error_keys = 'De sleutel "%s" bestaat bij vele meldingen : %s';
14 | 
15 | # Import issues
16 | $s_plugin_Csv_import_manage_issues_link = 'Importeer CSV file';
17 | $s_plugin_Csv_import_manage_issues = 'CSV importeren';
18 | $s_plugin_Csv_import_issues_file = 'Importeer meldingen van CSV file';
19 | $s_plugin_Csv_import_issues_columns = 'Bestands kolommen';
20 | $s_plugin_Csv_import_skip_first_line = 'Sla eerste bestandsregel over';
21 | $s_plugin_Csv_import_file_button = 'Importeer bestand';
22 | $s_plugin_Csv_import_column_number = 'Kolom #%d';
23 | $s_plugin_Csv_import_result_failure_ct = 'Tegengekomen fouten voor %d meldingen';
24 | $s_plugin_Csv_import_result_import_success_ct = '%d meldingen succesvol geïmporteerd';
25 | $s_plugin_Csv_import_result_update_success_ct = '%d meldingen succesvol gewijzigd';
26 | $s_plugin_Csv_import_error_nolines = 'Er moet minimaal één regel met gegevens zijn om te importeren';
27 | $s_plugin_Csv_import_error_empty_header = 'Er mag geen lege titelregel zijn wanneer de eerste rgel overgeslagen wordt';
28 | $s_plugin_Csv_import_error_noseparator = 'Elke regel moet het scheidingsteken "%s" hebben';
29 | $s_plugin_Csv_import_error_col_count = 'Elke regel moet hetzelfde aantal "%s" scheidingstekens hebben';
30 | $s_plugin_Csv_import_error_file_not_found = 'Bestand niet gevonden';
31 | $s_plugin_Csv_import_error_file_not_writable = 'Kan bestand niet wegschrijven';
32 | $s_plugin_Csv_import_error_file_not_opened = 'Kan bestand niet openen';
33 | $s_plugin_Csv_import_error_col_multiple = 'Zelfde kolom meer dan één keer gedefinieerd';
34 | $s_plugin_Csv_import_error_bug_not_exist = 'Melding %d bestaat niet';
35 | $s_plugin_Csv_import_error_bug_bad_project = 'Melding %d bestaat niet in het huidige project';
36 | $s_plugin_Csv_import_error_any = 'Fout tijdens melding "%s"';
37 | $s_plugin_Csv_import_error_custom_field = 'Fout tijdens importeren gebruikersveld "%s" voor melding "%s"';
38 | $s_plugin_Csv_import_error_col_select_multiple = 'De volgende velden zijn geselecteerdvoor meer dan n kolom:';
39 | 
40 | # Errors
41 | $MANTIS_ERROR['plugin_Csv_import_ERROR_ALL_PROJECT'] = 'Selecteer een project om te importeren';
42 | $MANTIS_ERROR['plugin_Csv_import_ERROR_FILE_FORMAT'] = 'Incorrect import bestandsformaat: %s';
43 | $MANTIS_ERROR['plugin_Csv_import_ERROR_FILE'] = 'Er is een probleem met het bestand zelf';
44 | 


--------------------------------------------------------------------------------
/lang/strings_english.txt:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | # Custom strings for english language
 4 | $s_plugin_Csv_import_title = 'Mantis CSV Importer';
 5 | $s_plugin_Csv_import_description = 'Import CSV files as Mantis issues';
 6 | $s_plugin_Csv_import_config = 'Configuration';
 7 | $s_plugin_Csv_import_update_config = 'Update configuration';
 8 | $s_plugin_Csv_import_file_format_col_spacer = 'CSV column separator';
 9 | $s_plugin_Csv_import_skip_blank_lines = 'Skip empty lines';
10 | $s_plugin_Csv_import_skip_blank_columns = 'Skip all columns following an empty header.';
11 | $s_plugin_Csv_import_create_unknown_cats = 'Create unknown categories';
12 | $s_plugin_Csv_import_tab_csv_separator = 'Use tab';
13 | $s_plugin_Csv_import_error_keys = 'The key "%s" exists on many bugs : %s';
14 | 
15 | # Import issues
16 | $s_plugin_Csv_import_manage_issues_link = 'Import CSV file';
17 | $s_plugin_Csv_import_manage_issues = 'CSV importing';
18 | $s_plugin_Csv_import_issues_file = 'Import issues from CSV file';
19 | $s_plugin_Csv_import_issues_columns = 'File columns';
20 | $s_plugin_Csv_import_skip_first_line = 'Skip first file line';
21 | $s_plugin_Csv_import_file_button = 'Import file';
22 | $s_plugin_Csv_import_column_number = 'Column #%d';
23 | $s_plugin_Csv_import_result_failure_ct = 'Encountered errors for %d issues';
24 | $s_plugin_Csv_import_result_nothing_success_ct = '%d unchanged issues';
25 | $s_plugin_Csv_import_result_import_success_ct = '%d issues successfully imported';
26 | $s_plugin_Csv_import_result_update_success_ct = '%d issues successfully updated';
27 | $s_plugin_Csv_import_error_nolines = 'There must be at least one line of data to import';
28 | $s_plugin_Csv_import_error_empty_header = 'There must not be empty header if skipping first line';
29 | $s_plugin_Csv_import_error_noseparator = 'Each line must have the separator "%s"';
30 | $s_plugin_Csv_import_error_col_count = 'Each line must have the same "%s" separator count';
31 | $s_plugin_Csv_import_error_file_not_found = 'File not found';
32 | $s_plugin_Csv_import_error_file_not_writable = 'Cannot write file';
33 | $s_plugin_Csv_import_error_file_not_opened = 'Cannot open file';
34 | $s_plugin_Csv_import_error_col_multiple = 'Same column defined more than once';
35 | $s_plugin_Csv_import_error_bug_not_exist = 'The bug %d does not exist';
36 | $s_plugin_Csv_import_error_bug_bad_project = 'The bug %d is not in the current project';
37 | $s_plugin_Csv_import_error_any = 'Error while treating the bug "%s"';
38 | $s_plugin_Csv_import_error_custom_field = 'Error while importing custom field "%s" for the bug "%s"';
39 | $s_plugin_Csv_import_error_col_select_multiple = 'The following fields have been selected for more than one column:';
40 | $s_plugin_Csv_import_max_file_size_label = 'Maximum size';
41 | 
42 | # Errors
43 | $MANTIS_ERROR['plugin_Csv_import_ERROR_ALL_PROJECT'] = 'A project must be selected to import issues';
44 | $MANTIS_ERROR['plugin_Csv_import_ERROR_FILE_FORMAT'] = 'Incorrect imported file format: %s';
45 | $MANTIS_ERROR['plugin_Csv_import_ERROR_FILE'] = 'There was an error with the file itself';
46 | $MANTIS_ERROR['plugin_Csv_import_ERROR_FILE_UPLOAD'] = 'Server can\'t store the uploaded file.';
47 | 


--------------------------------------------------------------------------------
/lang/strings_french.txt:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | # Custom strings for french language
 4 | $s_plugin_Csv_import_title = 'Importeur CSV Mantis';
 5 | $s_plugin_Csv_import_description = 'Importe des fichiers CSV comme bogues Mantis';
 6 | $s_plugin_Csv_import_config = 'Configuration';
 7 | $s_plugin_Csv_import_update_config = 'Mettre la configuration à jour';
 8 | $s_plugin_Csv_import_file_format_col_spacer = 'Séparateur de colonnes CSV';
 9 | $s_plugin_Csv_import_skip_blank_lines = 'Ignorer les lignes vides';
10 | $s_plugin_Csv_import_skip_blank_columns = 'Ignorer toutes les colonnes avec un en-tête vide';
11 | $s_plugin_Csv_import_create_unknown_cats = 'Créer automatiquement les catégories inconnues';
12 | $s_plugin_Csv_import_tab_csv_separator = 'Utiliser la tabulation';
13 | $s_plugin_Csv_import_error_keys = 'La clé "%s" existe sur plusieurs bogues : %s';
14 | 
15 | # Import issues
16 | $s_plugin_Csv_import_manage_issues_link = 'Importer un fichier CSV';
17 | $s_plugin_Csv_import_manage_issues = 'Import CSV';
18 | $s_plugin_Csv_import_issues_file = 'Importer des bogues depuis un fichier CSV';
19 | $s_plugin_Csv_import_issues_columns = 'Colonnes du fichier';
20 | $s_plugin_Csv_import_skip_first_line = 'Ignorer la première ligne';
21 | $s_plugin_Csv_import_file_button = 'Importer le fichier';
22 | $s_plugin_Csv_import_column_number = 'Colonne nº%d';
23 | $s_plugin_Csv_import_result_failure_ct = 'Erreurs rencontrées pour %d bogues';
24 | $s_plugin_Csv_import_result_nothing_success_ct = '%d bogues sans rien à changer';
25 | $s_plugin_Csv_import_result_import_success_ct = '%d bogues importés avec succès';
26 | $s_plugin_Csv_import_result_update_success_ct = '%d bogues mis à jour avec succès';
27 | $s_plugin_Csv_import_error_nolines = 'Il doit y avoir au moins une ligne à importer';
28 | $s_plugin_Csv_import_error_empty_header = 'Il ne doit pas y avoir d\'en-tête vide lorsque la première ligne est ignorée';
29 | $s_plugin_Csv_import_error_noseparator = 'Chaque ligne doit contenir le séparateur "%s"';
30 | $s_plugin_Csv_import_error_col_count = 'Chaque ligne doit avoir le même nombre de séparateur "%s"';
31 | $s_plugin_Csv_import_error_file_not_found = 'Fichier non trouvé';
32 | $s_plugin_Csv_import_error_file_not_writable = 'Impossible d\'écrire dans le fichier';
33 | $s_plugin_Csv_import_error_file_not_opened = 'Impossible d\'ouvrir le fichier';
34 | $s_plugin_Csv_import_error_col_multiple = 'La même colonne est définie plusieurs fois';
35 | $s_plugin_Csv_import_error_bug_not_exist = 'Le bogue %d n\'existe pas';
36 | $s_plugin_Csv_import_error_bug_bad_project = 'Le bogue %d n\'est pas dans le projet courrant';
37 | $s_plugin_Csv_import_error_any = 'Erreur lors du traitement du bogue "%s"';
38 | $s_plugin_Csv_import_error_custom_field = 'Erreur lors de l\import du champ personnalisé "%s" pour le bogue "%s"';
39 | $s_plugin_Csv_import_error_col_select_multiple = 'Les champs suivants ont sélectionnés pour plus d\'une fois :';
40 | 
41 | # Errors
42 | $MANTIS_ERROR['plugin_Csv_import_ERROR_ALL_PROJECT'] = 'Un projet doit être sélectionné pour importer des incidents.';
43 | $MANTIS_ERROR['plugin_Csv_import_ERROR_FILE_FORMAT'] = 'Le format du fichier importé est incorrect : %s.';
44 | $MANTIS_ERROR['plugin_Csv_import_ERROR_FILE'] = 'Erreur rencontrée dans le fichier.';
45 | $MANTIS_ERROR['plugin_Csv_import_ERROR_FILE_UPLOAD'] = 'Le serveur ne peut pas stocker le fichier uploadé.';
46 | 


--------------------------------------------------------------------------------
/lang/strings_german.txt:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | # Custom strings for german language
 4 | $s_plugin_Csv_import_title = 'Mantis CSV Import Probleme';
 5 | $s_plugin_Csv_import_description = 'Import CSV files as Mantis issues';
 6 | $s_plugin_Csv_import_config = 'Konfiguration';
 7 | $s_plugin_Csv_import_update_config = 'Aktualisiere Konfiguration';
 8 | $s_plugin_Csv_import_file_format_col_spacer = 'CSV Spalten Trennzeichen';
 9 | $s_plugin_Csv_import_skip_blank_lines = 'Leere Zeilen auslassen';
10 | $s_plugin_Csv_import_skip_blank_columns = 'Alle Spalten, die einem leeren Eintrag folgen, auslassen';
11 | $s_plugin_Csv_import_create_unknown_cats = 'Create unknown categories';
12 | $s_plugin_Csv_import_tab_csv_separator = 'Use tab';
13 | $s_plugin_Csv_import_error_keys = 'The key "%s" exists on many bugs : %s';
14 | 
15 | # Import issues
16 | $s_plugin_Csv_import_manage_issues_link = 'CSV Datei imporierten';
17 | $s_plugin_Csv_import_manage_issues = 'CSV Probleme importieren';
18 | $s_plugin_Csv_import_issues_file = 'Importiere Probleme aus einer CSV Datei';
19 | $s_plugin_Csv_import_issues_columns = 'Datei Spalten';
20 | $s_plugin_Csv_import_skip_first_line = 'Erste Zeile der Datei auslassen';
21 | $s_plugin_Csv_import_file_button = 'Importiere Datei';
22 | $s_plugin_Csv_import_column_number = 'Spalte #%d';
23 | $s_plugin_Csv_import_result_failure_ct = 'Bei %d Problemen traten Fehler auf';
24 | $s_plugin_Csv_import_result_import_success_ct = '%d Probleme erfolgreich importiert';
25 | $s_plugin_Csv_import_result_update_success_ct = '%d Probleme erfolgreich aktualisiert';
26 | $s_plugin_Csv_import_error_nolines = 'Es muss mindestens eine Zeile zu importieren sein';
27 | $s_plugin_Csv_import_error_empty_header = 'There must not be empty header if skipping first line';
28 | $s_plugin_Csv_import_error_noseparator = 'Jede Zeile muss das Trennzeichen "%s" enthalten';
29 | $s_plugin_Csv_import_error_col_count = 'Jede Zeile muss die Gleiche Anzahl des Trennzeichens "%s" enthalten';
30 | $s_plugin_Csv_import_error_file_not_found = 'Datei konnte nicht gefunden werden';
31 | $s_plugin_Csv_import_error_file_not_writable = 'Cannot write file';
32 | $s_plugin_Csv_import_error_file_not_opened = 'Cannot open file';
33 | $s_plugin_Csv_import_error_col_multiple = 'Die gleiche Spalte wurde mehr als einmal definiert';
34 | $s_plugin_Csv_import_error_bug_not_exist = 'Das Problem %d existiert nicht';
35 | $s_plugin_Csv_import_error_bug_bad_project = 'Das Problem %d ist nicht im aktuellen Projekt enthalten';
36 | $s_plugin_Csv_import_error_any = 'Bei der Verarbeitung des Problems "%s" trat ein Fehler auf';
37 | $s_plugin_Csv_import_error_custom_field = 'Beim Import des benutzerdefinierten Feldes "%s" zu Problem "%s" trat ein Fehler auf';
38 | $s_plugin_Csv_import_error_col_select_multiple = 'The following fields have been selected for more than one column:';
39 | 
40 | # Errors
41 | $MANTIS_ERROR['plugin_Csv_import_ERROR_ALL_PROJECT'] = 'Es muss ein Projekt bestimmt werden, um Probleme zu importieren';
42 | $MANTIS_ERROR['plugin_Csv_import_ERROR_FILE_FORMAT'] = 'Das Dateiformat ist nicht korrekt: %s';
43 | $MANTIS_ERROR['plugin_Csv_import_ERROR_FILE'] = 'Die Datei ist fehlerhaft';
44 | 


--------------------------------------------------------------------------------
/lang/strings_italian.txt:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | # Custom strings for italian language
 4 | $s_plugin_Csv_import_title = 'Importatore CSV in Mantis';
 5 | $s_plugin_Csv_import_description = 'Importa file CSV come issues in Mantis';
 6 | $s_plugin_Csv_import_config = 'Configurazione';
 7 | $s_plugin_Csv_import_update_config = 'Aggiorna configurazione';
 8 | $s_plugin_Csv_import_file_format_col_spacer = 'Separatore CSV di colonna';
 9 | $s_plugin_Csv_import_skip_blank_lines = 'Salta le righe vuote';
10 | $s_plugin_Csv_import_skip_blank_columns = 'Salta tutte le colonne che seguono un\'intestazione vuota.';
11 | $s_plugin_Csv_import_create_unknown_cats = 'Crea categorie sconosciute';
12 | $s_plugin_Csv_import_tab_csv_separator = 'Usa tab';
13 | $s_plugin_Csv_import_error_keys = 'La chiave "%s" esiste su molteplici bugs : %s';
14 | 
15 | # Import issues
16 | $s_plugin_Csv_import_manage_issues_link = 'Importa file CSV';
17 | $s_plugin_Csv_import_manage_issues = 'Importazione di CSV';
18 | $s_plugin_Csv_import_issues_file = 'Importa issue da file CSV';
19 | $s_plugin_Csv_import_issues_columns = 'Colonne del file';
20 | $s_plugin_Csv_import_skip_first_line = 'Salta la prima riga del file';
21 | $s_plugin_Csv_import_file_button = 'Importa file';
22 | $s_plugin_Csv_import_column_number = 'Colonna #%d';
23 | $s_plugin_Csv_import_result_failure_ct = 'Errori riscontrati per %d issues';
24 | $s_plugin_Csv_import_result_import_success_ct = '%d issue importati correttamente';
25 | $s_plugin_Csv_import_result_update_success_ct = '%d issue aggiornati correttamente';
26 | $s_plugin_Csv_import_error_nolines = 'Deve esistere almeno una riga di dati da importare';
27 | $s_plugin_Csv_import_error_empty_header = 'Intestazione vuota non ammessa se la prima riga deve essere ignorata';
28 | $s_plugin_Csv_import_error_noseparator = 'Ogni riga deve usare il separatore "%s"';
29 | $s_plugin_Csv_import_error_col_count = 'Ogni riga deve avere lo stesso numero di separatori "%s"';
30 | $s_plugin_Csv_import_error_file_not_found = 'File non trovato';
31 | $s_plugin_Csv_import_error_file_not_writable = 'Impossibile scrivere il file';
32 | $s_plugin_Csv_import_error_file_not_opened = 'Impossibile aprire il file';
33 | $s_plugin_Csv_import_error_col_multiple = 'Stessa colonna presente piu\' volte';
34 | $s_plugin_Csv_import_error_bug_not_exist = 'Il bug %d non esiste';
35 | $s_plugin_Csv_import_error_bug_bad_project = 'Il bug %d non fa parte del progetto corrente';
36 | $s_plugin_Csv_import_error_any = 'Errore nel trattamento del bug "%s"';
37 | $s_plugin_Csv_import_error_custom_field = 'Errore d\'importazione del campo personalizzato "%s" per il bug "%s"';
38 | $s_plugin_Csv_import_error_col_select_multiple = 'I campi seguenti sono stati selezionati per piu\' di una colonna:';
39 | 
40 | # Errors
41 | $MANTIS_ERROR['plugin_Csv_import_ERROR_ALL_PROJECT'] = 'Selezionare un progetto per importare gli issue';
42 | $MANTIS_ERROR['plugin_Csv_import_ERROR_FILE_FORMAT'] = 'Formato non corretto per il file da importare: %s';
43 | $MANTIS_ERROR['plugin_Csv_import_ERROR_FILE'] = 'Errore riscontrato sul file medesimo';
44 | 


--------------------------------------------------------------------------------
/pages/config.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | auth_reauthenticate();
 3 | access_ensure_global_level( config_get( 'manage_plugin_threshold' ) );
 4 | 
 5 | layout_page_header( plugin_lang_get( 'title' ) );
 6 | layout_page_begin( __FILE__ );
 7 | 
 8 | print_manage_menu();
 9 | 
10 | $t_import_issues_threshold = plugin_config_get( 'import_issues_threshold' );
11 | ?>
12 | 
13 | <br />
14 | 
15 | <div class="col-xs-12 col-md-8 col-md-offset-2">
16 | 	<div class="space-10"></div>
17 | 	<div id="config-div" class="form-container">
18 | 		<form id="config-form" method="post" action="<?php echo plugin_page( 'config_edit' ) ?>">
19 | 			<div class="widget-box widget-color-blue2">
20 | 				<div class="widget-header widget-header-small">
21 | 					<h4 class="widget-title lighter">
22 | 						<i class="ace-icon fa fa-user"></i>
23 | 						<?php echo plugin_lang_get( 'title' ) . ': ' . plugin_lang_get( 'config' ) ?>
24 | 					</h4>
25 | 				</div>
26 | 				<div class="widget-body">
27 | 					<div class="widget-main no-padding">
28 | 						<div class="form-container">
29 | 							<div class="table-responsive">
30 | 								<table class="table table-bordered table-condensed table-striped">
31 | 									<fieldset>
32 | 										<!-- mantistouch_url -->
33 | 										<tr>
34 | 											<td class="category">
35 | 												<?php echo lang_get( 'access_level' ) ?>
36 | 											</td>
37 | 											<td>
38 | 												<select name="import_issues_threshold">
39 | 													<?php print_enum_string_option_list( 'access_levels', $t_import_issues_threshold ) ?>
40 | 												</select>
41 | 											</td>
42 | 										</tr>
43 | 									</fieldset>
44 | 								</table>
45 | 							</div>
46 | 						</div>
47 | 					</div>
48 | 
49 | 					<div class="widget-toolbox padding-8 clearfix">
50 | 						<input type="submit" class="btn btn-primary btn-white btn-round" value="<?php echo plugin_lang_get( 'update_config' ) ?>" />
51 | 					</div>
52 | 				</div>
53 | 			</div>
54 | 		</form>
55 | 	</div>
56 | 	<div class="space-10"></div>
57 | </div>
58 | 
59 | <?php
60 | layout_page_end();
61 | 


--------------------------------------------------------------------------------
/pages/config_edit.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | auth_reauthenticate();
 3 | access_ensure_global_level( config_get( 'manage_plugin_threshold' ) );
 4 | 
 5 | $f_import_issues_threshold = gpc_get_int( 'import_issues_threshold', 70 );
 6 | 
 7 | plugin_config_set( 'import_issues_threshold', $f_import_issues_threshold );
 8 | 
 9 | print_header_redirect( plugin_page( 'config', true ) );
10 | 


--------------------------------------------------------------------------------
/pages/import_issues.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | # Mantis - a php based bugtracking system
  3 | 
  4 | require_once( 'core.php' );
  5 | $t_core_path = config_get( 'core_path' );
  6 | require_once( $t_core_path . 'category_api.php' );
  7 | require_once( $t_core_path . 'database_api.php' );
  8 | require_once( $t_core_path . 'user_api.php' );
  9 | require_once( $t_core_path . 'bug_api.php' );
 10 | access_ensure_project_level( config_get( 'manage_site_threshold' ) );
 11 | require_once( dirname( __FILE__ ) . DIRECTORY_SEPARATOR . 'import_issues_inc.php' );
 12 | 
 13 | # Check a project is selected
 14 | $g_project_id = helper_get_current_project();
 15 | if( $g_project_id == ALL_PROJECTS ) {
 16 | 	plugin_error( 'ERROR_ALL_PROJECT', ERROR );
 17 | }
 18 | 
 19 | # Get submitted data
 20 | $f_create_unknown_cats = gpc_get_bool( 'cb_create_unknown_cats' );
 21 | $f_import_file = gpc_get_string( 'import_file' );
 22 | $f_columns = gpc_get_string_array( 'columns' );
 23 | $f_skip_first = gpc_get_bool( 'cb_skip_first_line' );
 24 | $f_separator = gpc_get_string('edt_cell_separator');
 25 | $f_keys = gpc_get_string_array( 'cb_keys', array() );
 26 | 
 27 | # Convert the order-based key array to column-based key array
 28 | $t = array();
 29 | foreach($f_keys as $aKey) {
 30 |    $t[$f_columns[$aKey]] = 'standard';
 31 | }
 32 | $f_keys = $t;
 33 | unset($t);
 34 | 
 35 | # Load custom field ids
 36 | $t_linked_ids = custom_field_get_linked_ids( $g_project_id );
 37 | $t_custom_fields = array();
 38 | 
 39 | # Get custom field id of primary keys
 40 | foreach($t_linked_ids as $cf_id) {
 41 | 	$t_def = custom_field_get_definition($cf_id);
 42 | 	$t_custom_col_name = $g_custom_field_identifier . $t_def['name'];
 43 | 
 44 | 	if ( in_array( $t_custom_col_name, $f_columns ) ) {
 45 | 		$t_custom_fields[$t_custom_col_name] = $cf_id;
 46 | 	}
 47 | 
 48 | 	if(isset($f_keys[$t_custom_col_name])) {
 49 | 		$f_keys[$t_custom_col_name] = $cf_id;
 50 | 	}
 51 | }
 52 | 
 53 | # Check given parameters - File
 54 | $t_file_content = array();
 55 | if( file_exists( $f_import_file ) ) {
 56 | 	$t_file_content = read_csv_file( $f_import_file );
 57 | } else {
 58 | 	error_parameters( plugin_lang_get( 'error_file_not_found' ) );
 59 | 	plugin_error( 'ERROR_FILE_FORMAT', ERROR );
 60 | }
 61 | 
 62 | # Check given parameters - Columns
 63 | if( count( $f_columns ) <= 0 ) {
 64 | 	trigger_error( ERROR_EMPTY_FIELD, ERROR );
 65 | }
 66 | 
 67 | # ignore_column have to be ... ignored
 68 | foreach ($f_columns as $key => $value) {
 69 | 	if ($value == 'ignore_column') {
 70 | 		unset($f_columns[$key]);
 71 | 	}
 72 | }
 73 | 
 74 | # Other columns check
 75 | if( count( $f_columns ) != count( array_unique( $f_columns ) ) ) {
 76 | 	error_parameters( plugin_lang_get( 'error_col_multiple' ) );
 77 | 	plugin_error( 'ERROR_FILE_FORMAT', ERROR );
 78 | }
 79 | 
 80 | # Some default values for filter
 81 | $t_page_number = 1;
 82 | $t_issues_per_page = 25;
 83 | $t_page_count = 0;
 84 | $t_issues_count = 0;
 85 | 
 86 | # Import file content
 87 | $t_success_count = array();
 88 | $t_success_count['update'] = 0;
 89 | $t_success_count['new'] = 0;
 90 | $t_success_count['nothing'] = 0;
 91 | 
 92 | $t_failure_count = 0;
 93 | $t_error_messages = '';
 94 | 
 95 | # Determine import mode
 96 | $t_import_mode = 'all_new';
 97 | if(array_isearch( 'id', $f_columns ) !== false) {
 98 | 	$t_import_mode = 'by_id';
 99 | }
100 | else {
101 | 	if(count($f_keys) > 0) {
102 | 		$t_import_mode = 'by_keys';
103 | 	}
104 | }
105 | 
106 | # Let's go
107 | $t_dry_mode = false;
108 | $lineNumber = 0;
109 | helper_begin_long_process( );
110 | 
111 | foreach( $t_file_content as $t_file_row ) {
112 | 	$lineNumber++;
113 |    $t_operation_type = 'undefined';
114 | 
115 | 	# Check if first row skipped
116 | 	if( $lineNumber == 1 && $f_skip_first ) {
117 | 		continue;
118 | 	}
119 | 
120 | 	# Explode into elements
121 | 	$t_file_row = read_csv_row( $t_file_row, $f_separator );
122 | 
123 | 	# Get Id
124 | 	$t_bug_id = null;
125 | 	switch($t_import_mode) {
126 | 		case 'by_id' :
127 | 			$t_operation_type = 'update';
128 | 			$t_bug_id = get_column_value( 'id', $t_file_row );
129 | 			break;
130 | 
131 | 		case 'by_keys' :
132 | 			$t_filter = filter_get_default();
133 | 			$t_filter[FILTER_PROPERTY_HIDE_STATUS_ID] = array(
134 | 				'0' => META_FILTER_ANY,
135 | 			);
136 | 
137 | 			$t_values_for_error = array();
138 | 			foreach($f_keys as $aKey => $v) {
139 | 			   $filterValue = array(get_column_value( $aKey, $t_file_row, '' ));
140 | 				if($v == 'standard') {
141 | 					$t_filter[$aKey] = $filterValue;
142 | 				}
143 | 				else {
144 | 					$t_filter['custom_fields'][$v] = $filterValue;
145 | 				}
146 | 				$t_values_for_error[] = $filterValue[0];
147 | 			}
148 | 
149 | 			$t_issues = filter_get_bug_rows( $t_page_number, $t_issues_per_page, $t_page_count, $t_issues_count, $t_filter );
150 | 
151 | 			switch($t_issues_count) {
152 | 				case 1:
153 | 	            $t_operation_type = 'update';
154 | 					$t_bug_id = $t_issues[0]->id;
155 | 					break;
156 | 				case 0:
157 | 				   $t_operation_type = 'new';
158 | 					$t_bug_id = null;
159 | 					break;
160 | 				default :
161 | 					$t_bugs_id = array();
162 | 					foreach($t_issues as $issue) {
163 | 						$t_bugs_id[] = $issue->id;
164 | 					}
165 | 
166 | 					$t_failure_count++;
167 | 					$t_error_messages .= sprintf( $lineNumber . ' : ' . plugin_lang_get( 'error_keys' ), implode('/', $t_values_for_error),
168 | 																										implode('/', $t_bugs_id)) . '<br />';
169 | 					continue 3;
170 | 			}
171 | 
172 | 			break;
173 | 
174 | 		default :
175 | 			$t_operation_type = 'new';
176 | 		   $t_bug_id = null;
177 | 	}
178 | 
179 | 	# If new, set default parameters
180 | 	if( $t_bug_id === null ) {
181 | 		#Default bug will be with default values
182 | 		$t_bug_data = new BugData;
183 | 
184 | 		$t_bug_data->project_id			= $g_project_id;
185 | 		$t_bug_data->category_id		= get_csv_import_category_id( $g_project_id, 'General' );
186 | 		$t_bug_data->reporter_id		= auth_get_current_user_id();
187 | 		$t_bug_data->priority			= config_get( 'default_bug_priority' );
188 | 		$t_bug_data->severity			= config_get( 'default_bug_severity' );
189 | 		$t_bug_data->reproducibility	= config_get( 'default_bug_reproducibility' );
190 | 		$t_bug_data->handler_id			= 0;
191 | 		$t_bug_data->status				= config_get( 'bug_submit_status' );
192 | 		$t_bug_data->resolution			= OPEN;
193 | 		$t_bug_data->view_state			= config_get( 'default_bug_view_status' );
194 | 		$t_bug_data->profile_id			= 0;
195 | 		$t_bug_data->due_date			= date_get_null();
196 | 	} else {
197 | 	   # If existing bug
198 | 		if( !bug_exists( $t_bug_id ) ) {
199 | 			$t_failure_count++;
200 | 			$t_error_messages .= sprintf( $lineNumber . ' : ' . plugin_lang_get( 'error_bug_not_exist' ), $t_bug_id) . '<br />';
201 | 			continue;
202 | 		}
203 | 		$t_bug_data = bug_get( $t_bug_id, true );
204 | 		if( $t_bug_data->project_id != $g_project_id ) {
205 | 			$t_failure_count++;
206 | 			$t_error_messages .= sprintf( $lineNumber . ' : ' . plugin_lang_get( 'error_bug_bad_project' ), $t_bug_id) . '<br />';
207 | 			continue;
208 | 		}
209 | 	}
210 | 
211 | 	# From selected columns, get value
212 | 
213 | 	$detectChanges = false;
214 | 	$callUpdate = false;
215 | 	$t_custom_fields_to_set = array();
216 | 	$t_date_submitted = null;
217 | 	$t_last_updated = null;
218 | 	$t_description_set = false;
219 | 
220 | 	foreach($f_columns as $i => $aColumn) {
221 | 	   $v = null;
222 |       $valueSet = true;
223 | 
224 | 	   switch($aColumn) {
225 | 	      case 'priority' :
226 | 	      case 'severity' :
227 | 	      case 'reproducibility' :
228 | 	      case 'projection' :
229 | 	      case 'eta' :
230 | 	      case 'view_state' :
231 |             $v = get_enum_column_value( $aColumn, $t_file_row, '' );
232 |             break;
233 | 	      case 'date_submitted' :
234 | 	      case 'last_updated' :
235 | 	         $v = get_date_column_value( $aColumn, $t_file_row, '' );
236 | 	         break;
237 | 	      case 'due_date' :
238 | 	         $v = get_date_column_value( $aColumn, $t_file_row, date_get_null() );
239 | 	         break;
240 | 	      case 'handler_id' :
241 | 	      case 'reporter_id' :
242 | 	         $v = get_user_column_value( $aColumn, $t_file_row, '' );
243 | 	         break;
244 | 	      case 'status' :
245 | 	      case 'resolution' :
246 |          	$v = get_column_value( $aColumn, $t_file_row );
247 |          	if($v != '' && !is_numeric($v)) {
248 |          		$v = get_enum_column_value( $aColumn, $t_file_row, '' );
249 |          	}
250 |          	break;
251 | 	      case 'summary' :
252 | 	      case 'os' :
253 | 	      case 'os_build' :
254 | 	      case 'platform' :
255 | 	      case 'version' :
256 | 	      case 'target_version' :
257 | 	      case 'build' :
258 | 	      case 'steps_to_reproduce' :
259 | 	      case 'additional_information' :
260 | 	      case 'fixed_in_version' :
261 | 	         $v = get_column_value( $aColumn, $t_file_row, '');
262 | 	         break;
263 | 	      case 'description' :
264 |              $t_description_set = true;
265 | 	         $v = get_column_value( $aColumn, $t_file_row, '');
266 | 	         break;
267 | 	      case 'category' :
268 | 	   	   $v = get_category_column_value('category', $t_file_row, $t_bug_data->project_id , null );
269 | 
270 |          	if( $v == null ) {
271 |          		$t_cat = trim ( get_column_value( 'category', $t_file_row ) );
272 |          		if( $t_cat != '' && $f_create_unknown_cats ) {
273 |          			get_csv_import_category_id($g_project_id, $t_cat);
274 |          			$v = get_category_column_value('category', $t_file_row, $t_bug_data->project_id , '' );
275 | 				} else {
276 | 					# If user hasn't selected create unknown categories, then select a default category
277 | 					# when category is not already defined.
278 | 					$v = config_get( 'default_category_for_moves' );
279 | 				}
280 |          	}
281 |          	
282 |          	$aColumn = 'category_id';
283 |          	
284 | 	         break;
285 | 	      default :
286 | 	         $valueSet = false;
287 | 	         if(isset($t_custom_fields[$aColumn])) {
288 | 				$t_id = $t_custom_fields[$aColumn];
289 | 				$t_def = custom_field_get_definition( $t_id );
290 | 
291 | 				# Prepare value
292 | 				if ( $t_def['type'] == CUSTOM_FIELD_TYPE_DATE ) {
293 | 					$t_value = get_date_column_value( $aColumn, $t_file_row, '' );
294 | 				} else {
295 | 					$t_value = get_column_value( $aColumn, $t_file_row );
296 | 				}
297 | 
298 |       			# Have to be different
299 |       			if( $t_bug_id && $t_value == custom_field_get_value( $t_id, $t_bug_id) ) {
300 |       				continue;
301 |       			}
302 | 
303 |       			$detectChanges = true;
304 | 
305 |       			$t_custom_fields_to_set[$t_id] = $t_value;
306 | 	         }
307 | 	   }
308 | 
309 | 	   if( $valueSet && ($t_bug_id === null || $t_bug_data->$aColumn != $v) ) {
310 | 	      $detectChanges = true;
311 | 
312 | 	      if($aColumn == 'date_submitted') {
313 |             $t_date_submitted = $v ;
314 | 	      } else if ( $aColumn == 'last_updated' ) {
315 | 	        $t_last_updated = $v;
316 | 	      } else {
317 |    			$t_bug_data->$aColumn = $v;
318 | 		      $callUpdate = true;
319 | 	      }
320 | 		}
321 | 	}
322 | 
323 | 	if( $t_operation_type == 'update' &&  !$detectChanges ) {
324 | 	   $t_operation_type = 'nothing';
325 | 	}
326 | 
327 | 	$t_success_count[$t_operation_type]++;
328 | 
329 | 	# Set values
330 | 	if(!$t_dry_mode && $t_operation_type != 'nothing') {
331 | 		if ( !$t_description_set ) {
332 | 			$t_bug_data->description = $t_bug_data->summary;
333 | 		}
334 | 	   # Set non-custom fields
335 |    	if( $t_bug_id === null) {
336 |    		$t_bug_id = $t_bug_data->create();
337 |    	} else {
338 |    		if( $callUpdate ) {
339 |    			$t_bug_data->update( true, ( false == $t_notify ) );
340 |    		}
341 |    	}
342 | 
343 |    	# Set custom fields (can be set only after bug creation)
344 |    	foreach($t_custom_fields_to_set as $t_id => $t_value) {
345 |       	if( custom_field_set_value( $t_id, $t_bug_id, $t_value ) ) {
346 |       		# Mantis core doesn't update "last_updated" when setting custom fields
347 |       		bug_update_date( $t_bug_id );
348 |       	}
349 |       	else {
350 |       	   $t_failure_count++;
351 |       	   $t_error_messages .= sprintf( $lineNumber . ' : ' . plugin_lang_get( 'error_custom_field' ),
352 |       	                                                   $t_def['name'], $t_bug_data->summary) . '<br />';
353 |             continue;
354 |       	}
355 |    	}
356 | 
357 |    	# Set date_submitted (can be set only after bug creation)
358 |    	if($t_date_submitted) {
359 |    	   bug_set_field( $t_bug_id, 'date_submitted', $t_date_submitted );
360 |    	}
361 | 
362 |    	# Set last_updated (can be set only after bug creation / updated)
363 |    	if ( $t_last_updated ) {
364 |    	   bug_set_field( $t_bug_id, 'last_updated', $t_last_updated );
365 |    	}
366 | 	}
367 | }
368 | 
369 | if( $t_failure_count == 0 ) {
370 | 	$t_redirect_url = 'view_all_bug_page.php';
371 | } else {
372 | 	$t_redirect_url = null;
373 | }
374 | 
375 | layout_page_header( null, $t_redirect_url );
376 | 
377 | if( $t_failure_count ) {
378 | 	$t_alert_style = 'alert-danger';
379 | } else {
380 | 	$t_alert_style = 'alert-success';
381 | }
382 | ?>
383 | 
384 | <div class="col-md-12 col-xs-12">
385 | 	<div class="space-10"></div>
386 | 	<div class="alert <?php echo $t_alert_style; ?>">
387 | 
388 | <?php
389 | echo sprintf( plugin_lang_get( 'result_update_success_ct'  ), $t_success_count['update']) . '<br />';
390 | echo sprintf( plugin_lang_get( 'result_import_success_ct'  ), $t_success_count['new']) . '<br />';
391 | echo sprintf( plugin_lang_get( 'result_nothing_success_ct' ), $t_success_count['nothing']) . '<br />';
392 | 
393 | if( $t_failure_count ) {
394 | 	echo '<b>'.sprintf( plugin_lang_get( 'result_failure_ct' ), $t_failure_count) . ' :</b><br />';
395 |    echo $t_error_messages . '<br/>';
396 | }
397 | print_bracket_link( $t_redirect_url, lang_get( 'proceed' ) );
398 | ?>
399 | </div>
400 | </div>
401 | 
402 | <?php
403 | layout_page_end( __FILE__ );
404 | 


--------------------------------------------------------------------------------
/pages/import_issues_inc.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | # The current project
  3 | $g_project_id = helper_get_current_project();
  4 | if( $g_project_id == ALL_PROJECTS )
  5 | {
  6 | 	plugin_error( 'ERROR_ALL_PROJECT', ERROR );
  7 | }
  8 | 
  9 | # This identify a custom field
 10 | $g_custom_field_identifier = 'custom_';
 11 | 
 12 | # All column names that can be used with this project
 13 | $g_all_fields = array();
 14 | if( config_is_set( 'csv_import_columns' ) ) {
 15 | 	$g_all_fields = config_get( 'csv_import_columns' );
 16 | };
 17 | if( count( $g_all_fields ) == 0 ) {
 18 | 	$g_all_fields = array(
 19 | 		'additional_information',
 20 | 		'build',
 21 | 		'category',
 22 | 		'date_submitted',
 23 | 		'description',
 24 | 		'due_date',
 25 | 		'eta',
 26 | 		'fixed_in_version',
 27 | 		'handler_id',
 28 | 		'id',
 29 | 		'last_updated',
 30 | 		'os',
 31 | 		'os_build',
 32 | 		'platform',
 33 | 		'priority',
 34 | 		'projection',
 35 | 		'reporter_id',
 36 | 		'reproducibility',
 37 | 		'resolution',
 38 | 		'severity',
 39 | 		'status',
 40 | 		'steps_to_reproduce',
 41 | 		'summary',
 42 | 		'target_version',
 43 | 		'version',
 44 | 		'view_state',
 45 | 	);
 46 | }
 47 | $g_all_fields = array_unique($g_all_fields);
 48 | 
 49 | foreach( custom_field_get_linked_ids( $g_project_id ) as $t_id ) {
 50 | 	$g_all_fields[] =
 51 | 		$g_custom_field_identifier . custom_field_get_field( $t_id, 'name' );
 52 | };
 53 | $g_all_fields[] = 'ignore_column'; # @@@ u.sommer added
 54 | $g_all_fields = prepare_all_fields_array( $g_all_fields );
 55 | 
 56 | # --------------------
 57 | function prepare_all_fields_array( $p_all_fields ) {
 58 | 	global $g_custom_field_identifier;
 59 | 
 60 | 	# Correspondance between field names and language identifiers
 61 | 	$t_translated_fields = array(
 62 | 		'reporter_id' => 'reporter',
 63 | 		'last_updated' => 'updated',
 64 | 		'handler_id' => 'assigned_to',
 65 | 		'os_build' => 'os_version',
 66 | 		'version' => 'product_version',
 67 | 		'view_state' => 'view_status',
 68 | 	);
 69 | 
 70 | 	# Create the translated array
 71 | 	$t_fields = array();
 72 | 	foreach( array_unique( $p_all_fields ) as $t_element )
 73 | 	{
 74 | 		$t_lang_id = $t_element;
 75 | 		if( strpos( $t_element, $g_custom_field_identifier ) === 0 )
 76 | 			$t_lang_id = substr( $t_element, strlen( $g_custom_field_identifier ) );
 77 | 		elseif( isset( $t_translated_fields[$t_element] ) )
 78 | 			$t_lang_id = $t_translated_fields[$t_element];
 79 | 		$t_fields[$t_element] = lang_get_defaulted( $t_lang_id );
 80 | 	}
 81 | 
 82 | 	# Set to all fields
 83 | 	return $t_fields;
 84 | }
 85 | 
 86 | # --------------------
 87 | function print_all_fields_option_list( $p_selected ) {
 88 | 	global $g_all_fields;
 89 | 	foreach( $g_all_fields as $t_element => $t_translated )
 90 | 	{
 91 | 		echo "<option value=\"$t_element\"";
 92 | 		check_selected( $t_element, $p_selected );
 93 | 		echo ">" . $t_translated . "</option>";
 94 | 	}
 95 | }
 96 | 
 97 | # --------------------
 98 | function csv_string_unescape( $p_string ) {
 99 | 	$t_wo_quotes = preg_replace( '/\A"(.*)"\z/sm', '${1}', $p_string );
100 | 	if( $t_wo_quotes !== $p_string )
101 | 		$t_wo_quotes = str_replace( '""', '"', $t_wo_quotes );
102 | 	return $t_wo_quotes;
103 | }
104 | 
105 | # --------------------
106 | function read_csv_file( $p_filename ) {
107 | 	$t_regexp = '/\G((?:[^"\r\n]+|"[^"]*")+)[\r|\n]*/sm';
108 | 
109 | 	$t_file_raw_content = file_get_contents( $p_filename );
110 | 
111 | 	# Convert special chars to html entities
112 | 	$t_file_content = mb_convert_encoding($t_file_raw_content, 'HTML-ENTITIES', "UTF-8");
113 | 
114 | 	preg_match_all($t_regexp, $t_file_content, $t_file_rows);
115 | 	return $t_file_rows[1];
116 | }
117 | 
118 | # --------------------
119 | function read_csv_row( $p_file_row, $p_separator ) {
120 | 	$t_regexp = '/\G(?:\A|\\' . $p_separator . ')([^"\\' . $p_separator . ']+|(?:"[^"]*")*)/sm';
121 | 
122 | 	preg_match_all($t_regexp, $p_file_row, $t_row_element);
123 | 
124 | 	# Return result
125 | 	return array_map( 'csv_string_unescape', $t_row_element[1] );
126 | }
127 | 
128 | function category_get_id_by_name_ne( $p_category_name, $p_project_id ) {
129 | 	# Don't cache categories as they can be added during the import process.
130 | 	$t_categories = category_get_all_rows( $p_project_id );
131 | 
132 | 	foreach ( $t_categories as $t_category ) {
133 | 		if( strcasecmp( $t_category['name'], $p_category_name ) == 0 ) {
134 | 			return (int)$t_category['id'];
135 | 		}
136 | 	}
137 | 
138 | 	return false;
139 | }
140 | 
141 | function prepare_output( $t_string , $t_encode_only = false ) {
142 | 	return string_html_specialchars( utf8_encode($t_string) );
143 | }
144 | 
145 | function get_csv_import_category_id( $p_project_id, $p_category_name ) {
146 | 	project_ensure_exists( $p_project_id );
147 | 
148 | 	$t_category_id = category_get_id_by_name_ne( $p_category_name, $p_project_id );
149 | 	if( !$t_category_id )
150 | 	{
151 | 		return category_add( $p_project_id, $p_category_name );
152 | 	}
153 | 
154 | 	return $t_category_id;
155 | }
156 | 
157 | # --------------------
158 | # Breaks up an enum string into num:value elements
159 | function explode_enum_string( $p_enum_string ) {
160 | 	return explode( ',', $p_enum_string );
161 | }
162 | # --------------------
163 | # Given one num:value pair it will return both in an array
164 | # num will be first (element 0) value second (element 1)
165 | function explode_enum_arr( $p_enum_elem ) {
166 | 	return explode( ':', $p_enum_elem );
167 | }
168 | 
169 | function array_isearch( $str , $array ) {
170 | 	foreach($array as $k => $v) {
171 | 		if(strcasecmp($str, $v) == 0) {
172 | 			return $k;
173 | 		}
174 | 	};
175 | 	return false;
176 | }
177 | 
178 | #-----------------------
179 | function get_enum_column_value( $p_name, $p_row, $p_default ) {
180 | 	$t_value = get_column_value( $p_name, $p_row );
181 | 	if( is_blank( $t_value ) ) return $p_default;
182 | 	# First chance, search element in language enumeration string
183 | 	$t_element_enum_string = lang_get( $p_name . '_enum_string' );
184 | 	$t_arr = explode_enum_string( $t_element_enum_string );
185 | 	$t_arr_count = count( $t_arr );
186 | 	for( $i = 0; $i < $t_arr_count; $i++ ) {
187 | 		$elem_arr = explode_enum_arr( $t_arr[$i] );
188 | 		if( $elem_arr[1] == $t_value ) {
189 | 			return $elem_arr[0];
190 | 		} elseif( $elem_arr[0] == $t_value ) {
191 | 				return $elem_arr[0];
192 | 		};
193 | 	};
194 | 
195 | 	# Second chance, search element in configuration enumeration string
196 | 	$t_element_enum_string = config_get( $p_name . '_enum_string' );
197 | 	$t_arr = explode_enum_string( $t_element_enum_string );
198 | 	$t_arr_count = count( $t_arr );
199 | 	for( $i = 0; $i < $t_arr_count; $i++ ) {
200 | 		$elem_arr = explode_enum_arr( $t_arr[$i] );
201 | 		if( $elem_arr[1] == $t_value ) {
202 | 			return $elem_arr[0];
203 | 		} elseif( $elem_arr[0] == $t_value )	{
204 | 				return $elem_arr[0];
205 | 		};
206 | 	};
207 | 	return $p_default;
208 | }
209 | 
210 | #-----------------------
211 | function get_date_column_value( $p_name, $p_row, $p_default ) {
212 | 	$t_date = get_column_value( $p_name, $p_row );
213 | 
214 | 	if(!is_blank($t_date))
215 | 	{
216 | 	   return is_numeric($t_date) ? $t_date : strtotime( $t_date );
217 | 	}
218 | 
219 | 	return $p_default;
220 | }
221 | 
222 | 
223 | function string_MkPretty( $t_str ) {
224 | 	$t_str = utf8_encode(strtolower(trim(utf8_decode($t_str))));
225 | 	$t_str = preg_replace('/\xfc/ui', 'ue', $t_str);
226 | 	$t_str = preg_replace('/\xf6/ui', 'oe', $t_str);
227 | 	$t_str = preg_replace('/\xe4/ui', 'ae', $t_str);
228 | 	$t_str = preg_replace('/\xdf/ui', 'ss', $t_str);
229 | 	return $t_str;
230 | }
231 | 
232 | 
233 | function get_user_column_value( $p_name, $p_row, $p_default ) {
234 | 	$t_username = get_column_value( $p_name, $p_row );
235 | 	if( is_blank( $t_username ) ) {
236 | 		return $p_default;
237 | 	}
238 | 
239 | 	if( ($t_user_id = user_get_id_by_name($t_username)) !== false ) {
240 | 		return $t_user_id;
241 | 	}
242 | 
243 | 	$t_username_pretty = string_MkPretty( $t_username );
244 | 	if ( $t_username_pretty !== $t_username ) {
245 | 		if ( $t_user_id = user_get_id_by_name( $t_username_pretty ) ) {
246 | 			return $t_user_id;
247 | 		}
248 | 	}
249 | 
250 | 	if ( strstr( $t_username, '@' ) === false ) {
251 | 		# User name can contain invalid email characters, example spaces.
252 | 		# Since this is an invalid email address anyway and user is not enabled, use md5.
253 | 		$t_email = md5( $t_username ) . '@localhost';
254 | 	} else {
255 | 		$t_email = $t_username;
256 | 	}
257 | 
258 | 	$t_password = time() . rand( 1, 10000 );
259 | 
260 | 	if( user_create(
261 | 			$t_username,
262 | 			$t_password,    # password
263 | 			$t_email,       # email address
264 | 			null,           # access_level
265 | 			false,          # protected
266 | 			false) ) {      # enabled - disable user - admin can reset password and enable.
267 | 		return user_get_id_by_name($t_username);
268 | 	}
269 | 
270 | 	return $p_default;
271 | }
272 | 
273 | #-----------------------
274 | function get_column_value( $p_name, $p_row, $p_default = '' ) {
275 | 	global $f_columns;
276 | 	$t_column = array_isearch( $p_name, $f_columns );
277 | 	$t_value = ( ($t_column === false) || (!isset( $p_row[$t_column] )) ) ? $p_default : utf8_encode(trim( $p_row[$t_column] ));
278 | 
279 | 	$t_value = str_replace( '\n', "\n", $t_value );
280 | 	return $t_value;
281 | }
282 | 
283 | #-----------------------
284 | function column_value_exists( $p_name, $p_row ) {
285 | 	global $f_columns;
286 | 	$t_column = array_isearch( $p_name, $f_columns );
287 | 	return (($t_column !== false) && (isset( $p_row[$t_column] ))) ? true : false;
288 | }
289 | 
290 | function get_category_column_value( $p_name, $p_row, $p_project, $p_default ) {
291 | 	$t_category_id = category_get_id_by_name_ne ( trim ( get_column_value( $p_name, $p_row ) ) , $p_project );
292 | 	return (($t_category_id === false) ? $p_default : $t_category_id);
293 | }
294 | 
295 | /**
296 |  * A more readable var_dump
297 |  *
298 |  * @param mixed
299 |  */
300 | function hvar_dump()
301 | {
302 | 	$numargs = func_num_args();
303 | 	$arg_list = func_get_args();
304 | 	echo '<pre style="text-align: left;">';
305 | 	for ($i = 0; $i < $numargs; $i++)
306 | 	{
307 | 		var_dump($arg_list[$i]);
308 | 	}
309 | 
310 | 	echo '</pre>';
311 | }
312 | 
313 | if( !function_exists( 'helper_alternate_class' ) ) {
314 | 	function helper_alternate_class() {
315 | 		return '';
316 | 	}
317 | }
318 | 


--------------------------------------------------------------------------------
/pages/import_issues_page_col_set.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 	# Mantis - a php based bugtracking system
  3 | 	require_once( 'core.php' );
  4 | 	access_ensure_project_level( plugin_config_get( 'import_issues_threshold' ) );
  5 | 
  6 | 	layout_page_header( plugin_lang_get( 'manage_issues' ) );
  7 | 	layout_page_begin( __FILE__ );
  8 | 
  9 | 	$import_it = plugin_page('import_issues');
 10 | 	?>
 11 | <br />
 12 | <?php
 13 | 	require_once( dirname( __FILE__ ) . DIRECTORY_SEPARATOR . 'import_issues_inc.php' );
 14 | 	# Look if the import file name is in the posted data
 15 | 	$f_import_file = gpc_get_file( 'import_file', -1 );
 16 | 
 17 | 	# Check fields are set
 18 | 	if ( is_blank( $f_import_file['tmp_name'] ) || ( $f_import_file['size'] == 0 ) ) {
 19 | 		plugin_error( 'ERROR_FILE_UPLOAD', ERROR );
 20 | 	}
 21 | 
 22 | 	# File analysis
 23 | 	$t_file_content = read_csv_file( $f_import_file['tmp_name'] );
 24 | 	$t_separator = gpc_get_string('edt_cell_separator');
 25 | 	$t_trim_columns = gpc_get_bool( 'cb_trim_blank_cols' );
 26 | 	$t_trim_rows = gpc_get_bool( 'cb_skip_blank_lines' );
 27 | 	$t_skip_first = gpc_get_bool( 'cb_skip_first_line' );
 28 | 	$t_create_unknown_cats = gpc_get_bool( 'cb_create_unknown_cats' );
 29 | 
 30 | 	$t_column_count = -1;
 31 | 	$t_column_title = array();
 32 | 	if( count( $t_file_content ) <= 0 ) {
 33 | 		error_parameters( plugin_lang_get( 'error_nolines' ) );
 34 | 		plugin_error( 'ERROR_FILE_FORMAT', ERROR );
 35 | 	}
 36 | 
 37 | 	foreach( $t_file_content as $t_key => &$t_file_line ) {
 38 | 		$t_elements = read_csv_row( $t_file_line, $t_separator );
 39 | 
 40 | 		# First line
 41 | 		if( $t_column_count < 0 ) {
 42 | 			#  If 0 or 1 column
 43 | 			if( count( $t_elements ) <= 1 ) {
 44 | 				error_parameters( sprintf( plugin_lang_get( 'error_noseparator' ), $t_separator) );
 45 | 				plugin_error( 'ERROR_FILE_FORMAT', ERROR );
 46 | 			}
 47 | 			elseif (
 48 | 				$t_trim_rows && (trim(implode(' ' , $t_elements)) == '')
 49 | 			) {
 50 | 				if( $t_skip_first ) {
 51 | 					error_parameters( plugin_lang_get('error_empty_header' ) );
 52 | 					plugin_error( 'ERROR_FILE_FORMAT', ERROR );
 53 | 				}
 54 | 				else {
 55 | 					$t_file_line = null;
 56 | 				}
 57 | 			}
 58 | 
 59 | 			if( $t_trim_columns ) {
 60 | 				for( $i = 0 ; $i < count($t_elements) ; $i++ ) {
 61 | 					if( trim($t_elements[$i]) == '' ) {
 62 | 						$t_elements = array_slice( $t_elements , 0 , $i );
 63 | 						break 1;
 64 | 					}
 65 | 				}
 66 | 			}
 67 | 			$t_column_count = count( $t_elements );
 68 | 			$t_column_title = $t_elements;
 69 | 		}
 70 | 
 71 | 		# Other lines
 72 | 		elseif( $t_column_count != count( $t_elements ) ) {
 73 | 			if( $t_trim_columns ) { # @@@ u.sommer added
 74 | 				$t_row = explode( $t_separator , $t_file_line );
 75 | 				$t_row = array_slice( $t_row , 0 , $t_column_count );
 76 | 				$t_file_line = implode( $t_separator , $t_row );
 77 | 			}
 78 | 			else {
 79 | 				error_parameters( sprintf( plugin_lang_get( 'error_col_count' ), $t_separator) );
 80 | 				plugin_error( 'ERROR_FILE_FORMAT', ERROR );
 81 | 			}
 82 | 		}
 83 | 
 84 | 		if (
 85 | 			$t_trim_rows && trim(implode(' ' , $t_elements)) == ''
 86 | 		) {
 87 | 			unset( $t_file_content[$t_key] );
 88 | 			$t_file_content = array_merge($t_file_content);
 89 | 		}
 90 | 	}
 91 | 
 92 | 	if( is_writable( $f_import_file['tmp_name'] ) ) {
 93 | 		if( $handle = fopen( $f_import_file['tmp_name'], "wb" ) ) {
 94 | 			foreach( $t_file_content as &$t_file_line ) {
 95 | 				$t_written = fwrite( $handle , $t_file_line . "\n" );
 96 | 			}
 97 | 			fclose( $handle );
 98 | 		}
 99 | 		else {
100 | 			error_parameters( plugin_lang_get( 'error_file_not_opened' ) );
101 | 			plugin_error( 'ERROR_FILE_FORMAT', ERROR );
102 | 		}
103 | 	}
104 | 	else {
105 | 		error_parameters( plugin_lang_get( 'error_file_not_writable' ) );
106 | 		plugin_error( 'ERROR_FILE_FORMAT', ERROR );
107 | 	}
108 | 
109 | 	# Move file
110 | 	$t_file_name = tempnam( dirname($f_import_file['tmp_name']), 'tmp' );
111 | 	move_uploaded_file( $f_import_file['tmp_name'], $t_file_name );
112 | ?>
113 | 
114 | <!-- Set fields form -->
115 | <div class="">
116 |    <div class="space-10"></div>
117 |    <div id="config-div" class="form-container">
118 |      <div class="widget-box widget-color-blue2">
119 |         <div class="widget-header widget-header-small">
120 |            <h4 class="widget-title lighter">
121 |               <?php echo $f_import_file['name'] ?>
122 |            </h4>
123 |         </div>
124 |         <div class="widget-body">
125 |            <div class="widget-main no-padding">
126 |               <div class="form-container">
127 |                  <div class="table-responsive">
128 |                     <table class="table table-bordered table-condensed table-hover table-striped">
129 |                        <fieldset>
130 | 						   <tr class="row-category">
131 | 	<?php
132 | 	# Write columns labels
133 | 	for( $i = 0; $i < $t_column_count; $i++ ) {
134 | 		echo '<td>';
135 | 		if( !$t_skip_first ) {
136 | 			echo sprintf( plugin_lang_get( 'column_number' ), $i + 1);
137 | 		}
138 | 		else {
139 | 			echo prepare_output($t_column_title[$i]);
140 | 		}
141 | 		echo '</td>';
142 | 	}
143 | 	?>
144 | 	</tr>
145 | <?php
146 | 	# Display first file lines
147 | 	$t_first_run = true;
148 | 	$t_display_max = 3;
149 | 
150 | 	foreach( $t_file_content as &$t_file_line ) {
151 | 		# Ignore columns labels
152 | 		if( $t_first_run && $t_skip_first ) {
153 | 			$t_first_run = false;
154 | 			continue;
155 | 		}
156 | 
157 | 		echo '<tr>';
158 | 
159 | 		# Still more lines (add "...")
160 | 		if( --$t_display_max < 0 ) {
161 | 			echo str_repeat('<td>&hellip;</td>', $t_column_count);
162 | 			echo '</tr>';
163 | 			break;
164 | 		}
165 | 		else {
166 | 			# Write values
167 | 			foreach( read_csv_row( $t_file_line, $t_separator ) as $t_element ) {
168 | 				echo '<td>' . prepare_output($t_element) . '</td>';
169 | 			}
170 | 		}
171 | 		echo '</tr>';
172 | 	}
173 | ?>
174 | </fieldset>
175 |                     </table>
176 |                  </div>
177 |               </div>
178 |            </div>
179 |         </div>
180 |      </div>
181 |    </div>
182 |    <div class="space-10"></div>
183 | </div>
184 | 
185 | <br />
186 | 
187 | <!-- Set fields form -->
188 | <div class="col-xs-12 col-md-8 col-md-offset-2">
189 |    <div class="space-10"></div>
190 |    <div id="config-div" class="form-container">
191 |       <form method="post" enctype="multipart/form-data" action="<?php echo $import_it ?>">
192 |          <div class="widget-box widget-color-blue2">
193 |             <div class="widget-header widget-header-small">
194 |                <h4 class="widget-title lighter">
195 |                   Column Mapping
196 |                </h4>
197 |             </div>
198 |             <div class="widget-body">
199 |                <div class="widget-main no-padding">
200 |                   <div class="form-container">
201 |                      <div class="table-responsive">
202 |                         <table class="table table-bordered table-condensed table-striped">
203 |                            <fieldset>
204 |                            	   <tr>
205 |                            	   	   <td>
206 |                            	   	       <?php echo plugin_lang_get( 'issues_columns' ) ?>
207 |                            	   	   </td>
208 |                            	   	   <td>
209 |                            	   	   	   Matching Action
210 |                            	   	   </td>
211 |                            	   	   <td>
212 |                            	   	       Primary Key
213 |                            	   	   </td>
214 |                            	   </tr>
215 | <?php
216 | 	$t_column_title = array_map( 'trim', $t_column_title );
217 | 
218 | 	for( $t_fields = $g_all_fields, $i = 0; $i < $t_column_count; next( $t_fields ), $i++ ) {
219 | 		if ( is_blank( $t_column_title[$i] ) ) {
220 | 			continue;
221 | 		}
222 | 
223 | 		# Map imported columns to fields.
224 | 		if ( strtolower( $t_column_title[$i] ) == 'id' ) {
225 | 			# By default use import as new issues mode rather than update issues with matching ids.
226 | 			$t_found_field = false;
227 | 		} else if( isset( $g_all_fields[$t_column_title[$i]] ) ) {
228 | 			$t_found_field = $t_column_title[$i];
229 | 		} else if( isset( $g_all_fields[ str_replace( '_id', '', $t_column_title[$i] ) ] ) ) {
230 | 			$t_found_field = str_replace( '_id', '', $t_column_title[$i] );
231 | 		} else
232 | 		{
233 | 			$t_found_field = array_isearch( prepare_output($t_column_title[$i]), $g_all_fields );
234 | 		}
235 | 
236 | 		# Write
237 | 		?>
238 | 		<tr>
239 | 			<td class="category">
240 | 				<?php
241 | 					if( !$t_skip_first ) {
242 | 						echo sprintf( plugin_lang_get( 'column_number' ), $i + 1);
243 | 					}
244 | 					else {
245 | 						echo prepare_output($t_column_title[$i]);
246 | 					}
247 | 				?>
248 | 			</td>
249 | 			<td>
250 | 				<select name="columns[]">
251 | 					<?php print_all_fields_option_list( $t_found_field !== false ? $t_found_field : 'ignore_column' ) ?>
252 | 				</select>
253 | 			</td>
254 | 			<td>
255 | 				<input type="checkbox" name="cb_keys[]" value="<?php echo $i?>"/>
256 | 			</td>
257 | 		</tr><?php
258 | 	}
259 | ?>
260 | 			<input type="hidden" name="cb_skip_first_line" value="<?php echo $t_skip_first ?>" />
261 | 			<input type="hidden" name="cb_skip_blank_lines" value="<?php echo $t_trim_rows ?>" />
262 | 			<input type="hidden" name="cb_trim_blank_cols" value="<?php echo $t_trim_columns ?>" />
263 | 			<input type="hidden" name="edt_cell_separator" value="<?php echo $t_separator ?>" />
264 | 			<input type="hidden" name="cb_create_unknown_cats" value="<?php echo $t_create_unknown_cats ?>" />
265 | 			<input type="hidden" name="import_file" value="<?php echo $t_file_name ?>" />
266 | </fieldset>
267 |                         </table>
268 |                      </div>
269 |                   </div>
270 |                </div>
271 |                <div class="widget-toolbox padding-8 clearfix">
272 | 			      <input type="submit" class="btn btn-primary btn-white btn-round" id="importForm" value="<?php echo plugin_lang_get( 'file_button' ) ?>" onclick="return checkFields();" />
273 |                </div>
274 |             </div>
275 |          </div>
276 |       </form>
277 |    </div>
278 |    <div class="space-10"></div>
279 | </div>
280 | 
281 | <script type="text/javascript">
282 | function checkFields() {
283 | 	var allDropdowns = document.getElementsByName("columns[]");
284 | 	var dropdownArray = [];
285 | 	var dupeArray = [];
286 | 	var dupeCnt = 0;
287 | 	for(var x = 0; x < allDropdowns.length; x++) {
288 | 		var currentDropdown = allDropdowns[x].options[allDropdowns[x].options.selectedIndex];
289 | 		if (dropdownArray.indexOf(currentDropdown.value) < 0) {
290 | 			dropdownArray[x] = currentDropdown.value;
291 | 		} else if (currentDropdown.value != 'ignore_column') {
292 | 			dupeArray[dupeCnt] = currentDropdown.text;
293 | 			dupeCnt++;
294 | 		}
295 | 	}
296 | 	if (dupeArray.length > 0) {
297 | 		alert('<?php echo str_replace('\'', '\\\'', plugin_lang_get( 'error_col_select_multiple' )) ?>\r\n\r\n' + dupeArray.toString().replace(/,/g, "\r\n"));
298 | 		return false;
299 | 	} else {
300 | 		return true;
301 | 	}
302 | }
303 | </script>
304 | 
305 | <?php
306 | layout_page_end();
307 | 


--------------------------------------------------------------------------------
/pages/import_issues_page_init.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | # Mantis - a php based bugtracking system
  3 | require_once( 'core.php' );
  4 | access_ensure_project_level( plugin_config_get( 'import_issues_threshold' ) );
  5 | 
  6 | layout_page_header( plugin_lang_get( 'manage_issues' ) );
  7 | layout_page_begin( __FILE__ );
  8 | 
  9 | $import_page = plugin_page('import_issues_page_col_set');
 10 | ?>
 11 | <br />
 12 | <?php
 13 | require_once( dirname( __FILE__ ) . DIRECTORY_SEPARATOR . 'import_issues_inc.php' );
 14 | 
 15 | $t_max_file_size = (int)min( ini_get_number( 'upload_max_filesize' ), ini_get_number( 'post_max_size' ),
 16 | config_get( 'max_file_size' ) );
 17 | ?>
 18 | 
 19 | <div class="col-xs-12 col-md-8 col-md-offset-2">
 20 |    <div class="space-10"></div>
 21 |    <div id="config-div" class="form-container">
 22 |       <form method="post" enctype="multipart/form-data" action="<?php echo $import_page ?>">
 23 |          <div class="widget-box widget-color-blue2">
 24 |             <div class="widget-header widget-header-small">
 25 |                <h4 class="widget-title lighter">
 26 |                   <?php echo plugin_lang_get( 'issues_file' ) ?>
 27 |                </h4>
 28 |             </div>
 29 |             <div class="widget-body">
 30 |                <div class="widget-main no-padding">
 31 |                   <div class="form-container">
 32 |                      <div class="table-responsive">
 33 |                         <table class="table table-bordered table-condensed table-striped">
 34 |                            <fieldset>
 35 |                               <tr>
 36 |                                  <td class="category">
 37 |                                     <input id="edt_cell_separator" name="edt_cell_separator" type="text" size="15" maxlength="1" value="<?php echo config_get( 'csv_separator' )?>" style="text-align:center"/>
 38 |                                  </td>
 39 |                                  <td>
 40 |                                     <?php echo plugin_lang_get( 'file_format_col_spacer' ) ?> -
 41 |                                     <a href="#" onclick="javascript:document.getElementById('edt_cell_separator').value=String.fromCharCode(9);">[<?php echo plugin_lang_get( 'tab_csv_separator' ) ?>]</a>
 42 |                                  </td>
 43 |                               </tr>
 44 | 
 45 |                               <tr>
 46 |                                  <td class="category" style="text-align:center">
 47 |                                     <input type="checkbox" name="cb_skip_first_line" value="1" checked="checked"/>
 48 |                                  </td>
 49 |                                  <td>
 50 |                                     <?php echo plugin_lang_get( 'skip_first_line' ) ?>
 51 |                                  </td>
 52 |                               </tr>
 53 | 
 54 |                               <tr>
 55 |                                  <td class="category" style="text-align:center">
 56 |                                     <input type="checkbox" name="cb_skip_blank_lines" value="1" checked="checked"/>
 57 |                                  </td>
 58 |                                  <td>
 59 |                                     <?php echo plugin_lang_get( 'skip_blank_lines' ) ?>
 60 |                                  </td>
 61 |                               </tr>
 62 | 
 63 |                               <tr>
 64 |                                  <td class="category" style="text-align:center">
 65 |                                     <input type="checkbox" name="cb_trim_blank_cols" value="1"/>
 66 |                                  </td>
 67 |                                  <td colspan="4">
 68 |                                     <?php echo plugin_lang_get( 'skip_blank_columns' ) ?>
 69 |                                  </td>
 70 |                               </tr>
 71 | 
 72 |                               <tr>
 73 |                                  <td class="category" style="text-align:center">
 74 |                                     <input type="checkbox" name="cb_create_unknown_cats" value="1"/>
 75 |                                  </td>
 76 |                                  <td colspan="4">
 77 |                                     <?php echo plugin_lang_get( 'create_unknown_cats' ) ?>
 78 |                                  </td>
 79 |                               </tr>
 80 | 
 81 |                               <tr>
 82 |                                  <td class="category" width="15%">
 83 |                                     <?php echo lang_get( 'select_file' ) ?><br />
 84 |                                     <?php echo '<span class="small">(' . plugin_lang_get( 'max_file_size_label' ) . ': ' . number_format( $t_max_file_size/1000 ) . 'k)</span>'?>
 85 |                                  </td>
 86 |                                  <td width="85%" colspan="2">
 87 |                                     <input type="hidden" name="max_file_size" value="<?php echo $t_max_file_size ?>" />
 88 |                                     <input type="file" name="import_file" size="40" />
 89 |                                  </td>
 90 |                               </tr>
 91 |                            </fieldset>
 92 |                         </table>
 93 |                      </div>
 94 |                   </div>
 95 |                </div>
 96 |                <div class="widget-toolbox padding-8 clearfix">
 97 |                   <input type="submit" class="btn btn-primary btn-white btn-round" value="<?php echo lang_get( 'upload_file_button' ) ?>" />
 98 |                </div>
 99 |             </div>
100 |          </div>
101 |       </form>
102 |    </div>
103 |    <div class="space-10"></div>
104 | </div>
105 | 
106 | <?php
107 | layout_page_end();
108 | 


--------------------------------------------------------------------------------