CN108920152B

CN108920152B - Method for adding custom attribute in bugzilla

Info

Publication number: CN108920152B
Application number: CN201810516508.5A
Authority: CN
Inventors: 徐潇
Original assignee: Zhengzhou Yunhai Information Technology Co Ltd
Current assignee: Zhengzhou Yunhai Information Technology Co Ltd
Priority date: 2018-05-25
Filing date: 2018-05-25
Publication date: 2021-07-23
Anticipated expiration: 2038-05-25
Also published as: CN108920152A

Abstract

The invention provides a method for adding custom attributes in bugzilla, which comprises the following steps: a database is created for adding and editing the variable new _ param, and the variable new _ param is added to the bugzilla default database table. The invention provides a simplified thought and a simplified method for modifying a source code, which can add a new variable in bugzilla and adopt a new database table as an introduced base point on the basis of not changing and influencing the original code and design, provide an interface for the modification of subsequent maintenance, and greatly improve the later cost of code modification and maintenance.

Description

Method for adding custom attribute in bugzilla

Technical Field

The invention relates to the field of software development management, in particular to a method for adding custom attributes in bugzilla.

Background

In the prior art, when an open-source Bugzilla code is applied to a product or Bug management of a user, when a new variable to be filled is added, only the type and input mode of the variable that have been designed in the Custom Fields in the Bugzilla code can be selected, including nine types, namely Date/Time, Integer, Bug ID, Multiple-Selection Box, Date, Large Text Box, Free Text, Drop Down, that are, the corresponding input mode is locked.

The fixed and unchangeable variable types and input modes in Bugzilla bring difficulty to the introduction of some special variables (such as the need of performing instant calculation on a page and the like). The user can not self-define the new variable and can not provide an interface for subsequent maintenance and modification, and the later cost of code modification and maintenance is greatly improved.

Disclosure of Invention

In order to solve the problems, the invention provides a method for adding custom attributes in bugzilla, which avoids modifying a large amount of original high-quality codes and adopts a new database table as a warehouse for adding and transmitting background data.

The technical task of the invention is realized by the following modes: the invention provides a method for adding custom attributes in bugzilla, which comprises the following steps: a database is created for adding and editing the variable new _ param, and the variable new _ param is added to the bugzilla default database table.

Further, the method comprises the following steps:

s1, adding a new database field _ new, and adding a variable new _ param into the newly generated database;

s2, adding a variable new _ param into the default database table of bugzilla;

s3, customizing an input mode, a display mode and a calculation mode of a variable new _ param in the front-end code, and transmitting the variable to the background perl code;

s4, updating the database content according to the new _ param value received in the background code;

s5, using update statement, importing the updated database content into bugzilla database.

Further, in step S1, the newly added database table field _ new primary key name is identical to the primary key name in the bug database default table.

Further, in step S2, a column is added to the default database table of bugzilla, and the column is used to add the variable new _ param.

Further, the new _ param variable type added in step S2 is the same as the variable type in the database field _ new and the variable attribute allows a null value.

Further, the specific implementation process in step S4 is as follows: filling default other data in the default database of bugzilla, leaving the newly introduced variable new _ param empty, and adding the updated content in the field _ new database into a newly added column of the bugzilla database by using the update statement in SQL, so as to facilitate the addition and customization of new variables.

Further, when updating the database content, the received new _ param value is written into the custom database field _ new together with the current bug _ id in the background code, i.e. a new variable is added to the database field _ new.

Further, if a new _ param value already exists in the custom database field _ new, a judgment statement is added, and the content of the bugzilla database is updated instead.

The invention has the beneficial effects that:

1. the invention avoids modifying a large amount of original high-quality codes and adopts a new database table as a warehouse for increasing and transmitting background data, thereby simplifying the difficulty of code modification and maintenance and saving the time and energy of development and code maintenance of programmers.

2. The invention provides a simplified thought and a simplified method for modifying a source code, and new variables can be added to bugzilla on the basis of not changing and influencing the original code and design.

3. The new data in the invention can adopt the new database table as the introduced site, thus providing an interface for the modification of the subsequent maintenance and greatly improving the later cost of code modification and maintenance.

Drawings

FIG. 1 is a diagram of the steps of the method of the present invention.

Detailed Description

The following detailed description of the embodiments of the present invention is provided in conjunction with the accompanying drawings, and the following disclosure provides specific embodiments of the apparatus and method for implementing the invention, so that those skilled in the art can more clearly understand how to implement the invention. To simplify the disclosure of the present invention, the components and arrangements of specific examples are described below. Furthermore, the present invention may repeat reference numerals and/or letters in the various examples. This repetition is for the purpose of simplicity and clarity and does not in itself dictate a relationship between the various embodiments or configurations discussed. It should be noted that the components illustrated in the figures are not necessarily drawn to scale. Descriptions of well-known components and processing techniques and procedures are omitted so as to not unnecessarily limit the invention. It should be understood that while the invention has been described in conjunction with the preferred specific embodiments thereof, that these are set forth merely for purposes of illustration and are not intended to limit the scope of the invention.

Bugzilla is an open source defect Tracking System (Bug Tracking System) that can manage the entire lifecycle of defect submission (new), repair (resolve), shutdown (close), etc. in software development.

It is known that when the open-source Bugzilla code is applied to the product or bug management, many different variables and attributes can be set by utilizing the powerful existing functions of the Bugzilla. However, the types of the added new variables can only be selected from the types and input modes of the variables already designed in the Custom Fields in the Bugzilla code.

It is easier to modify the front-end code to implement new variables that are visible on the Web side. The technical difficulty is actually declaring a new variable in the intricate perl code and adding it to the original database. This does not sound as complex, but looking at the bugzilla's source code, one sees that a variable (e.g., bug version) appears in the code as many as 86 times and is distributed among 26 different code files. The calling relationship between each other is complicated and complicated.

The key difficulty is that each variable in the table is already determined by the bugzilla database when the bugzilla database is newly built, and a plurality of judgment functions exist in the code, such as field in post _ bug. Modifying parts of the above codes in turn involves more file codes, which is certainly a time-consuming task. How to simplify this introduced process is then the key to the problem resolution.

As shown in FIG. 1, the present invention proposes a method for adding custom attributes to bugzilla. The method comprises the following steps:

s1, add a new database field _ new, add the variable new _ param to the newly created database. Specifically, MySQL Workbench can be selected to establish a database, a new table is established, and data is added to the table.

S2, add a column in the bug default database table, the column is used to add the variable new _ param. For example, a column is added to the bug default database table bug, i.e. the new _ param variable needs to be added, note that the variable type is the same as in the table field _ new, and the variable attribute must be chosen to allow null values.

S3, defining the input mode, the display mode and the calculation mode of the variable new _ param in the front-end code by user, and transmitting the variable to the background perl code. Perl provides all the functionality of scripting languages (e.g., sed and awk), and it also supports the translation of sed to Perl and awd to Perl. As with scripting languages, Perl does not require a compiler and linker to run the code.

S4, the new _ param value received in the background code updates the database content. Wherein the received new _ param value is written into the custom database field _ new together with the current bug _ id in the background code, i.e. a new variable is added to the database field _ new. If the new _ param value already exists in the customized database field _ new, the judgment statement is added, and the content of the bugzilla database is updated instead.

S5, using update statement, importing the updated database content into bugzilla database. The default database of bugzilla has already filled in default other data, and the newly introduced variable new _ param is still empty; and updating the content in the database table field _ new into the table bug by using the update statement, namely realizing the addition of the new variable.

In the modification process of the code, the fact that the judgment and the verification for multiple times in the processes of simplifying the modification difficulty and number of the code is found to solve a problem that errors are caused in the updating and reading processes of the database information. The update statement in SQL can be used, and the content of the original table in the database can be updated by using another table without influencing the original data. Namely, the invention can customize various attributes such as the type, the input mode, the display mode and the like of the variable according to the requirement of the product.

Moreover, the scope of the present application is not intended to be limited to the particular embodiments of the process, machine, manufacture, composition of matter, means, methods and steps described in the specification. As one of ordinary skill in the art will readily appreciate from the disclosure of the present invention, processes, machines, manufacture, compositions of matter, means, methods, or steps, presently existing or later to be developed, that perform substantially the same function or achieve substantially the same result as the corresponding embodiments described herein may be utilized according to the present invention. Accordingly, the appended claims are intended to include within their scope such processes, machines, manufacture, compositions of matter, means, methods, or steps.

Claims

1. A method for adding custom attributes in bugzilla is characterized by comprising the following steps:

s2, adding a column into the default database table of bugzilla, wherein the column is used for adding a variable new _ param;

s4, receiving the value of new _ param in the background code, and updating the database content;

2. The method for adding custom attributes to bugzilla as claimed in claim 1, wherein in step S1, the newly added database table field _ new primary key name is identical to the primary key name in the bug database default table.

3. The method of claim 1, wherein in step S2, a column is added to the default database table of bugzilla for adding a new variable new _ param.

4. The method of claim 1, wherein the new _ param variable type added in step S2 is the same as the variable type in the database field _ new and the variable attribute can be set to null.

5. The method for adding custom attributes to bugzilla according to claim 1, wherein the specific process of updating the database content in step S4 is as follows: in the background code, the received new _ param value is written to the custom database field _ new, along with the current bug _ id, where a new variable is added.

6. The method as claimed in claim 4, wherein if there is a new _ param value in the custom database field _ new, then add the judgment statement to update the bugzilla database content.

7. The method for adding custom attributes to bugzilla according to claim 1, wherein the specific implementation procedure in step S4 is as follows: filling default other data in the default database of bugzilla, leaving the newly introduced variable new _ param empty, and adding the updated content in the field _ new database to a newly added column of the bugzilla database by using the update statement in SQL to add a new variable.