CN111326035A - Task synchronization method and remote teaching system - Google Patents

Abstract

The invention discloses a task synchronization method and a remote teaching system, wherein the task synchronization method is suitable for the remote teaching system and comprises the following steps: the method comprises the steps that a student client determines a first interface registered in a Gitlab service deployed in a task page according to detected task submitting operation in the task page displayed in an accessed network classroom; calling a first interface, and synchronizing task data related to task submission operation to a teacher client; the teacher client displays the tasks submitted by the student clients according to the task data in the correction page displayed in the accessed network classroom; performing task correction operation detection in the displayed task, and determining a second interface registered in a Gitlab service deployed by a correction page according to the detected task correction operation; and calling a second interface, and feeding back a task correction result related to the task correction operation to the student client. The invention solves the problem of low correction efficiency in the prior art.

Description

Task synchronization method and remote teaching system

Technical Field

The invention relates to the technical field of computers, in particular to a task synchronization method and a remote teaching system.

Background

With the development of computer technology, people can carry out remote teaching through a network classroom. When remote teaching is carried out, a teacher can carry out lectures in an online classroom accessed by a teacher client, and students can listen to the lectures in the online classroom accessed by a student client.

In the process of remote teaching, the teacher can also arrange tasks to the students by means of a network classroom, for example, the tasks are the writing of code items, so as to check the lecture listening effect of the students. Specifically, the student sends the completed task to the teacher in a file transmission mode, and the teacher performs online system entry on the completion condition of the student after completing the correction of the task locally.

From the above, the above-mentioned correction process is broken, resulting in low correction efficiency.

Disclosure of Invention

In order to solve the problem of low correction efficiency in the related art, embodiments of the present invention provide a task synchronization method and a remote teaching system.

The technical scheme adopted by the invention is as follows:

in a first aspect of the disclosed embodiments of the present invention, a task synchronization method is applicable to a remote teaching system, where the system includes clients accessing to an online classroom, the clients include a student client and a teacher client, and the method includes: the student client determines a first interface registered in a Gitlab service deployed in a task page according to the detected task submitting operation in the task page displayed in the accessed network classroom; calling the first interface, and synchronizing task data related to the task submitting operation to the teacher client; the teacher client displays the tasks submitted by the student clients according to the task data in the correction page displayed in the accessed network classroom; performing task correction operation detection in the displayed task, and determining a second interface registered in a Gitlab service deployed by the correction page according to the detected task correction operation; and calling the second interface, and feeding back a task correcting result related to the task correcting operation to the student client.

In a second aspect of the disclosed embodiment of the present invention, a remote teaching system comprises a student client and a teacher client which are accessed to an online classroom, wherein the student client is configured to determine, in a task page displayed in the accessed online classroom, a first interface registered in a Gitlab service deployed by the task page according to a detected task submission operation; the student client is also used for calling the first interface and synchronizing task data related to the task submitting operation to the teacher client; the teacher client is used for displaying tasks submitted by the student clients in a differentiation mode according to the task data in a correction page displayed in the accessed network classroom; the teacher client is further used for performing task correction operation detection in the displayed tasks and determining a second interface registered in the Gitlab service deployed in the correction page according to the detected task correction operation; the teacher client is further used for calling the second interface and feeding back a task correcting result related to the task correcting operation to the student client.

In a third aspect of the embodiments disclosed herein, an electronic device includes a processor and a memory, where the memory stores computer-readable instructions, and the computer-readable instructions, when executed by the processor, implement the task synchronization method as described above.

In a fourth aspect of the embodiments disclosed herein, a computer-readable storage medium has stored thereon a computer program which, when executed by a processor, implements the task synchronization method as described above.

In the technical scheme, the whole correction process is completely based on the online classroom in the remote teaching process, so that the cutting of the correction process is avoided.

Specifically, the student client determines a first interface registered in a Gitlab service deployed in a task page according to the detected task submitting operation in the task page displayed in the accessed network classroom, and synchronizes task data related to the task submitting operation to the teacher client through the calling of the first interface.

For the teacher client, displaying tasks submitted by the student clients according to task data in the correction pages displayed in the accessed network classroom, determining a second interface registered in a Gitlab service deployed in the correction pages when detecting that task correction operation is triggered in the displayed tasks, and feeding back task correction results related to the task correction operation to the student clients through calling of the second interface.

Therefore, based on the deployment of the Gitlab service, whether the task submission is carried out by students or the task correction is carried out by teachers, the task correction can be realized by means of a network classroom, the whole correction process is continuous and convenient, and the correction efficiency is effectively improved.

It is to be understood that both the foregoing general description and the following detailed description are exemplary and explanatory only and are not restrictive of the invention, as claimed.

Drawings

The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate embodiments consistent with the invention and together with the description, serve to explain the principles of the invention.

FIG. 1 is a schematic illustration of an implementation environment in accordance with the present invention.

Fig. 2 is a block diagram illustrating a hardware configuration of a terminal according to an exemplary embodiment.

FIG. 3 is a flowchart illustrating a method of task synchronization according to an example embodiment.

Fig. 4 is a schematic diagram of a task page according to the corresponding embodiment in fig. 3.

Fig. 5 is a schematic diagram of an approval page according to the corresponding embodiment in fig. 3.

FIG. 6 is a flow diagram illustrating another method of task synchronization in accordance with an exemplary embodiment.

Fig. 7 is a diagram illustrating task submission request initiation according to the embodiment shown in fig. 6.

FIG. 8 is a flow diagram illustrating another method of task synchronization in accordance with an exemplary embodiment.

Fig. 9 is a schematic diagram illustrating initiation of a task modification request according to the embodiment shown in fig. 8.

FIG. 10 is a flowchart of one embodiment of step 530 in the corresponding embodiment of FIG. 9.

Fig. 11 is a schematic diagram of an entry of the correction task shown in the correction page according to the embodiment of fig. 10.

FIG. 12 is a flow chart of one embodiment of step 350 of the corresponding embodiment of FIG. 3.

FIG. 13 is a flowchart of one embodiment of step 355 of the corresponding embodiment of FIG. 12.

FIG. 14 is a flow diagram illustrating another method of task synchronization in accordance with an exemplary embodiment.

FIG. 15 is a flowchart illustrating another method of task synchronization in accordance with an exemplary embodiment.

Fig. 16 is a schematic diagram illustrating establishment of a binding relationship according to the corresponding embodiment in fig. 15.

FIG. 17 is a flowchart of one embodiment of step 730 of the corresponding embodiment of FIG. 15.

FIG. 18 is a flowchart illustrating another method of task synchronization in accordance with an exemplary embodiment.

Fig. 19 is a schematic diagram of an interface call query according to the corresponding embodiment of fig. 18.

FIG. 20 is a block diagram illustrating a task synchronization apparatus in accordance with an exemplary embodiment.

FIG. 21 is a block diagram illustrating an electronic device in accordance with an example embodiment.

While specific embodiments of the invention have been shown by way of example in the drawings and will be described in detail hereinafter, such drawings and description are not intended to limit the scope of the inventive concepts in any way, but rather to explain the inventive concepts to those skilled in the art by reference to the particular embodiments.

Detailed Description

Reference will now be made in detail to the exemplary embodiments, examples of which are illustrated in the accompanying drawings. When the following description refers to the accompanying drawings, like numbers in different drawings represent the same or similar elements unless otherwise indicated. The embodiments described in the following exemplary embodiments do not represent all embodiments consistent with the present invention. Rather, they are merely examples of apparatus and methods consistent with certain aspects of the invention, as detailed in the appended claims.

Fig. 1 is a schematic diagram of an implementation environment involved in a task synchronization method. The implementation environment includes a terminal 110, a web server 130, and a Gitlab server 150.

Specifically, the terminal 110 may be operated by a client providing a remote teaching function, and may be a desktop computer, a notebook computer, a tablet computer, a palm computer, a personal digital assistant, a smart phone, and the like, which is not limited herein.

The client provides a remote teaching function, for example, the remote teaching client, the browser client, and the like may be in the form of an application program or a web page, and accordingly, the user interface displayed by the client may be in the form of a program window or a web page.

The network server 130 constructs a database corresponding to the network classroom to store data related to the network classroom, for example, an account number, raw data, and the like of the network classroom corresponding to the network classroom. The network server 130 may be one server, a server cluster composed of a plurality of servers, or a cloud computing center composed of a plurality of servers, and is not limited specifically herein. The server is a computer device providing a background service to a user, for example, the background service includes a remote teaching service and the like.

The network connection between the terminal 110 and the network server 130 is pre-established in a wireless or wired manner, so as to implement data transmission between the terminal 110 and the network server 130 through the established network connection, for example, the transmitted data includes a network classroom account number, an original data approval task item, and the like corresponding to a network classroom.

The Gitlab server 150 is responsible for providing deployment of the Gitlab service, for example, deploying the Gitlab service in a task page, a correction page, etc. displayed in a network classroom, so as to implement data intercommunication between the Gitlab server 150 and the network server 130, even between the Gitlab server and the terminal 110, for example, the synchronized data includes task data, task correction results, correction task entries, etc.

In the remote teaching process, the terminal 110 includes a first terminal and a second terminal, and the remote teaching client includes a student client and a teacher client. The first terminal can be operated by a teacher client, the second terminal can be operated by a student client, the teacher client can be accessed to a network classroom so as to facilitate the teacher to give lessons, and the student client can be accessed to the network classroom so as to facilitate the students to listen to lessons.

If the teacher also arranges tasks for the students by means of the network classroom, for example, the tasks are the writing of code items, and then for the student client, after submitting the tasks in the task page displayed by the network classroom, task data related to the submitted tasks can be synchronized to the teacher client based on the Gitlab service deployed by the task page.

For the teacher client, after the task correction is completed in the correction page displayed in the online classroom, the task correction result can be fed back to the student client based on the Gitlab service deployed on the correction page.

Referring to fig. 2, fig. 2 is a block diagram illustrating a terminal according to an example embodiment. Such a terminal is suitable for use in the terminal 100 in the implementation environment shown in fig. 1.

It should be noted that this terminal is only an example adapted to the present invention and should not be considered as providing any limitation to the scope of use of the present invention. Nor should such a terminal be construed as requiring reliance on, or necessity of, one or more of the components of the exemplary terminal 100 shown in fig. 2.

The hardware structure of the terminal 200 may be greatly different due to the difference of configuration or performance, as shown in fig. 2, the terminal 200 includes: a power supply 210, an interface 230, at least one memory 250, and at least one Central Processing Unit (CPU) 270.

Specifically, power supply 210 is used to provide operating voltages for the various components on terminal 200.

The interface 230 includes at least one wired or wireless network interface 231, at least one serial-to-parallel conversion interface 233, at least one input/output interface 235, and at least one USB interface 237, etc. for communicating with external devices. For example, communication between the terminal 100 and the network server side 130 shown in the fig. 1 implementation environment is enabled.

The storage 250 is used as a carrier for resource storage, and may be a read-only memory, a random access memory, a magnetic disk or an optical disk, etc., and the resources stored thereon include an operating system 251, an application 253, data 255, etc., and the storage manner may be a transient storage or a permanent storage.

The operating system 251 is used for managing and controlling each component and the application 253 on the terminal 200, so as to implement the computation and processing of the mass data 255 by the central processing unit 270, which may be Windows server, Mac OS XTM, UnixTM, linux, FreeBSDTM, or the like.

The application 253 is a computer program that performs at least one specific task on the operating system 251, and may include at least one module (not shown in fig. 2), each of which may contain a series of computer-readable instructions for the terminal 200. For example, the client performing the remote teaching may be regarded as an application 253 deployed on the terminal 200 to implement the task synchronization method.

The data 255 may be a photograph or a picture, or may be task data or a task modification result, and is stored in the memory 250.

The central processor 270 may include one or more processors and is configured to communicate with the memory 250 via the communication bus to read the computer-readable instructions stored in the memory 250, and further to implement the operation and processing of the mass data 255 in the memory 250. The task synchronization method is accomplished, for example, by the central processor 270 reading a series of computer readable instructions stored in the memory 250.

The display screen 280 may be a liquid crystal display, an electronic ink display, or the like, and the display screen 280 provides an output interface between the terminal 200 and the user so that output contents formed by any one or combination of text, pictures, or videos can be displayed to the user through the output interface. For example, a task page, an amending page, etc. are presented in a webclass, or a task item is displayed in a task page and an amending task item is displayed in an amending page, etc.

The input component 290 may be a touch layer covered on the display screen 280, a key, a track ball or a touch pad arranged on the housing of the terminal 200, or an external keyboard, a mouse, a touch pad, etc. for obtaining various operations triggered by the user. Such as a task submission operation, a task modification operation, a task selection operation, a modification task selection operation, and so forth.

It will be appreciated that the configuration shown in fig. 2 is merely illustrative, and that terminal 200 may include more or fewer components than shown in fig. 2, or have different components than shown in fig. 2. The components shown in fig. 2 may be implemented in hardware, software, or a combination thereof.

Referring to fig. 3, in an exemplary embodiment, a task synchronization method is applied to a terminal in the implementation environment shown in fig. 1, and the structure of the terminal may be as shown in fig. 2.

The task synchronization method may be executed by a terminal, or may be understood as being executed by a client running in the terminal, for example, a remote teaching client. In the following method embodiments, for convenience of description, the execution subject of each step is described as a client, but the method is not limited thereto. The client comprises a student client and a teacher client.

The task synchronization method can comprise the following steps:

and 310, determining a first interface registered in a Gitlab service deployed in a task page according to the detected task submitting operation in the task page displayed in the accessed network classroom by the student client.

Firstly, the network classroom is constructed by the client running on the terminal, that is, when the client runs on the terminal, the network classroom is correspondingly constructed along with the network connection established between the terminal and the network server, at this time, the student client can be accessed to the network classroom to listen to classes, and the teacher client can be accessed to the network classroom to give classes, so as to realize remote teaching.

As described above, in the course of remote teaching, the teacher may arrange a task to the student via the webclassroom, for example, the task is the writing of a code item, thereby checking the effect of the student on the class. In this embodiment, the task that the teacher arranged for the student is shown to the student through the task page, that is, the task page shows the task that the teacher arranged for the student, so that the student submits the task.

In order to solve the splitting of the correction process in the prior art, the task page is provided with the Gitlab service, in other words, the student client can enjoy the Gitlab service provided by the Gitlab server through the task page.

Specifically, a Gitlab server is set up for remote teaching, so that tasks submitted by students can be managed through the strong management capacity of the Gitlab server. It will also be understood that the Gitlab server acts as a "repository" that stores tasks submitted by students, i.e., providing Gitlab services to student clients.

In order to manage tasks submitted by students by the Gitlab server, the Gitlab server provides a native page to clients (such as student clients) performing remote teaching, and the native page enables the tasks submitted by the students by means of the student clients to be stored in the Gitlab server, namely, enables the student clients to enjoy Gitlab service. The native page refers to an original page provided by the Gitlab server and not subjected to secondary development.

Further, after the native page is obtained, secondary development needs to be performed on the native page to generate a task page with the Gitlab service deployed, so that students can conveniently submit tasks based on the task page, and the submitted tasks are stored in the Gitlab server.

For example, as shown in fig. 4, based on the native page, development of user interface elements such as a task dialog 302, a "submit job" button 303, and a "cancel" button is completed through the control and displayed, so that a task page 301 in which the Gitlab service is deployed is obtained.

Then, for the student client, after the task page with the Gitlab service deployed is generated, the task page with the Gitlab service deployed can be displayed along with the access of the network classroom, so that the task arranged by the teacher can be displayed for the student.

Secondly, in order to facilitate the students to submit completed tasks to teachers, in this embodiment, a task submission entry is provided in the task page, and the students can trigger task submission operations through the task submission entry.

Taking the writing of a task as an example of a code item, as shown in fig. 4, in a task page 301, when a student completes writing the code item in a task dialog box 302, the student can click a "submit job" button 303 to submit the task. The "submit job" button 303 is a task submission entry in the task page 301, and the click operation is a task submission operation triggered at the task submission entry.

It should be noted that the specific behavior of the task submitting operation may also be different according to different input components configured on the terminal (e.g., a touch layer overlaid on a display screen, a mouse, a keyboard, etc.). For example, in the case of a smartphone that is input through a touch layer, the task submission operation may be a gesture operation such as a click or a slide, and in the case of a personal computer that is configured with a mouse, the task submission operation may be a mechanical operation such as a drag, a click, or a double click, and is not limited in particular.

When a student triggers a task submitting operation at a task submitting entrance, the student client can detect the task submitting operation, and then the student is informed that the student completes the task and needs to submit the task to a teacher.

At the moment, the student client determines a first interface registered in the Gitlab service deployed on the task page, and submits the task completed by the student to the teacher through the calling of the first interface. Namely, the first interface realizes the intercommunication of task data between the Gitlab server and the teacher client.

The first interface is registered in a Gitlab service deployed in a task page, and the essence means that the first interface is defined in a Gitlab server providing the Gitlab service, so that the Gitlab server can know that the first interface is used for submitting a task completed by a student to a teacher. That is, through the first interface definition, the Gitlab server knows: the data transmitted by the interface is the tasks completed by the students, and the data is destined for the teacher client.

Step 330, invoking the first interface, and synchronizing task data related to the task submission operation to the teacher client.

And the task data is related to the task submitting operation and is used for describing the tasks submitted by the students.

As illustrated in fig. 4, when the student completes writing a code item in the task dialog 302, the "submit job" button 303 may trigger a task submitting operation, and then the student writes the input code in the task dialog 302, i.e., the task data related to the task submitting operation.

At this time, based on the Gitlab service deployed by the task page, the tasks submitted by the students via the task page are stored in the Gitlab server, and based on the first interface registered in the Gitlab service, the Gitlab server can inform the teacher client to perform task data intercommunication.

Optionally, considering that there is more than one student client accessing the network classroom, and accordingly there are multiple tasks submitted by the students, the data intercommunication between the Gitlab server and the teacher client may also be performed based on the network server, so as to improve the correction efficiency of the teacher client.

Specifically, the network server side establishes a database corresponding to the network classroom and is used for storing tasks submitted by students with the help of student clients accessed to the network classroom, at the moment, the Gitlab server firstly calls the first interface to synchronize the tasks submitted by the students to the database corresponding to the network classroom, and then the intercommunication of task data with the teacher client is realized through the database corresponding to the network classroom.

And 350, displaying the tasks submitted by the student client side according to the task data in the correction page displayed in the accessed network classroom by the teacher client side.

After the teacher client acquires the task data related to the task submitting operation, namely the tasks submitted by the students by means of the student clients, the tasks can be displayed to the teacher by means of the teacher client.

In this embodiment, the tasks submitted by the students to the teacher are displayed to the teacher through the correction page, that is, the correction page displays the tasks submitted by the students to the teacher, so that the teacher can conveniently perform task correction.

Still taking writing of a task as a code item as an example for explanation, as shown in fig. 4, if the "submit job" button 303 is triggered to submit a task, the task data related to the task submitting operation is the code written by the student in the task dialog box 302, and then, when the teacher client acquires the task data, as shown in fig. 5, in the correction page 305, the tasks submitted by the student client are displayed as 3061 and 3062.

And 370, performing task correction operation detection in the displayed task, and determining a second interface registered in the Gitlab service deployed in the correction page according to the detected task correction operation.

The correction page is provided with the Gitlab service, namely, the teacher client can enjoy the Gitlab service provided by the Gitlab server through the correction page, so that the problem of splitting in the correction process in the prior art is solved.

Specifically, based on setting up the Gitlab server for remote teaching, not only are tasks submitted by students managed, but also tasks (namely task correction results) submitted by teachers are managed, namely Gitlab service is provided for the teacher client.

In order to manage tasks submitted by the teacher through the Gitlab server, the Gitlab server provides a native page to a client (such as a teacher client) for remote teaching, and the native page enables the tasks submitted by the teacher through the teacher client to be stored in the Gitlab server, namely, enables the teacher client to enjoy the Gitlab service.

Further, after the native page is obtained, secondary development needs to be performed on the native page to generate a correction page with the deployed Gitlab service, so that a teacher can conveniently perform task correction based on the correction page.

For example, as shown in fig. 5, development of user interface elements such as an approval dialog 307 is completed through a control based on a native page, and the development is displayed, so that an approval page 305 in which a gillab service is deployed is obtained.

In order to facilitate the teacher to correct the task submitted by the student, in the embodiment, a task correction entry is provided in the correction page, and the teacher can trigger the task correction operation in the task correction entry.

Taking writing of a task as a code item as an example, as shown in fig. 5, in the correction page 305, based on the displayed tasks 3061 and 3062 submitted by the student, the teacher can check the correctness of the code written by the student, and further input a modification suggestion, a score, and the like in the correction dialog 307. The correction dialog 307 is a task correction entry in the correction page 305, and the input operation is a task correction operation triggered by the task correction entry.

Similarly, in the task submitting operation, the specific behavior of the task modifying operation may be different according to different input components (such as a touch screen, a mouse, a keyboard, and the like) configured in the terminal, and will not be described repeatedly herein.

When the teacher triggers the task correction operation at the task correction entry, the teacher client can detect the task correction operation, and further know that the teacher finishes correcting the task submitted by the student, and needs to feed back to the student about the task correction result of the teacher, such as correction suggestion, score and the like.

At this time, the teacher client determines a second interface registered in the Gitlab service deployed on the correction page, so that the task correction result of the teacher is fed back to the students through the call of the second interface. Namely, the second interface realizes the intercommunication of task batch-and-correction results between the Gitlab server and the student client.

The second interface is registered in a Gitlab service deployed on a correction page, and the essence means that the second interface is defined in a Gitlab server providing the Gitlab service, so that the Gitlab server can know that the second interface is used for feeding back a task correction result of a teacher to students. That is, through the second interface definition, the Gitlab server knows: the data transmitted by the interface is the task correction result of the teacher, and the data destination is the student client.

And step 390, calling the second interface, and feeding back a task correcting result related to the task correcting operation to the student client.

And the task correction result is related to the task correction operation. As illustrated in fig. 5, the teacher enters modification suggestions, scores, and the like in the modification dialog 307, and this input operation is regarded as a task modification operation, and accordingly, the modification suggestions, scores, and the like are regarded as a task modification result related to the task modification operation.

Then, based on the gillab service deployed by the modification page, the task modification result generated by the teacher through the modification page is stored in the gillab server, and based on the second interface registered in the gillab service, the gillab server can notify the student client to perform intercommunication of the task modification result.

Optionally, similar to the intercommunication of task data between the Gitlab server and the teacher client, the intercommunication of task correction results between the Gitlab server and the student client can also be performed based on the network server, so as to improve the correction efficiency of the teacher client, and the description is not repeated here.

Through the process, the relation chain data (such as task data and task correction results) between the students and teachers are communicated to the deployed Gitlab service without being separated from the network classroom, so that the continuity and convenience of the whole correction process are realized, and the efficiency of the correction process is effectively improved.

In an application scene, as a student client is accessed to an online classroom, students can directly submit tasks based on the online classroom, namely, the students enter a task page to complete tasks arranged by teachers; and as the teacher client accesses the online classroom, the teacher can directly modify the tasks based on the online classroom, namely, the teacher enters a modification page to modify the tasks submitted by the students. In the whole correction process, a teacher does not need to correct tasks locally, and does not need to perform on-line system input of student completion conditions, and the correction is realized on the basis of a network classroom, so that the correction is coherent and convenient, and the correction efficiency is greatly improved.

Referring to fig. 6, in an exemplary embodiment, before step 310, the method as described above may further include the following steps:

step 410, in the teaching page displayed in the network classroom accessed by the student client, the student client receives a task submitting request.

And 430, jumping to the task page from the teaching page according to the task submitting request.

It can be understood that students can access to the network classroom to listen to the class by means of the student client, and usually, when the class finishes listening to the class, the students can only finish the tasks arranged by the teachers aiming at the class.

Based on this, in this embodiment, the display of the task page is performed based on the task submission request.

Specifically, a submission request initiating entry is provided in a teaching page displayed in a network classroom accessed by a student client, and when a student wants to complete a task arranged by a teacher, the student can trigger related operations at the submission request initiating entry.

For example, as shown in FIG. 7, in a teaching page 401, an "enter item" button 402 is clicked, i.e., a student is deemed to want to complete a task arranged by a teacher. The "enter item" button 402 is a submit request initiating entry in the teaching page 401, and the clicking operation is a related operation triggered by the submit request initiating entry.

When the student client detects that the submission request initiates the relevant operation triggered by the entry, the student client regards that the task submission request is received, and then the teaching page jumps to the task page so as to display the task page in the network classroom accessed by the student client.

Of course, considering that there may be multiple tasks for the student, to this end, in an exemplary embodiment, step 430 may further include the steps of:

and responding to the task submission request, jumping from the teaching page to a task viewing page, and displaying task items.

And acquiring task selection operation aiming at the task items in the task viewing page, jumping to the task page from the task viewing page according to the task selection operation, and displaying the tasks corresponding to the selected task items.

The students can check brief information of all tasks, such as task submission date, task scores and the like, and the tasks are submitted and also include the tasks which are not submitted. At this time, if the student desires to view or submit one of the tasks, the corresponding task entry is selected, and the selection operation is regarded as a task selection operation.

Similarly, in the task submitting operation, the specific behavior of the correction task selecting operation may be different according to different input components (such as a touch screen, a mouse, a keyboard, and the like) configured in the terminal, and the detailed description is not repeated here.

Then, after the task selection operation is obtained, the student client jumps to a task page, and displays the task corresponding to the selected task item.

Referring to fig. 8, in an exemplary embodiment, before step 350, the method as described above may further include the steps of:

step 510, in a teaching page displayed in a network classroom accessed by the teacher client, the teacher client receives a task correction request.

And 530, jumping from the teaching page to the correcting page according to the task correcting request, and displaying correcting task items.

It can be understood that the teacher can access the network classroom to carry out lectures by means of the teacher client, and generally, when the lecture in the teacher is finished, the teacher can possibly correct the tasks submitted by the students aiming at the teacher, and then the lecture listening effect of the students on the teacher is checked.

Based on this, in this embodiment, the display of the correction page is performed based on the task correction request.

Specifically, a correction request initiating entry is provided in a teaching page displayed in a network classroom accessed by a teacher client, and when the teacher wants to correct a task submitted by a student, the correction request initiating entry can trigger related operations.

For example, as shown in FIG. 9, in a teaching page 501, an "enter item" button 502 is clicked, i.e., a teacher is considered to want to approve a task submitted by a student. The "enter item" button 502 is a correction request initiation entry in the teaching page 501, and the clicking operation is a related operation triggered by the correction request initiation entry.

When the teacher client detects that the correction request initiates the relevant operation triggered by the entry, the teacher client determines that the task correction request is received, and then the teaching page jumps to the correction page so as to display the correction page in the network classroom accessed by the teacher client.

Similarly, in the task submitting operation, the specific behaviors of the related operations triggered by the entries (the submission request initiating entry and the correction request initiating entry) may be different according to different input components (such as a touch screen, a mouse, a keyboard, and the like) configured by the terminal, and are not described repeatedly herein.

It should be appreciated that the same teacher, the student who needs to modify, may submit more than one task, and thus, for the display of the modification page, it is essential to perform the display of the modification task entry.

Further, in an exemplary embodiment, as shown in fig. 10, step 530 may include the steps of:

and 531, responding to the task correcting request, and skipping from the teaching page to the correcting page.

Step 533, obtaining a correction task item corresponding to the teacher client, and displaying the obtained correction task item in the correction page.

As shown in fig. 11, in the correction page 503, several correction task items are displayed, as shown in 504. It can be seen that different correction task items can correspond to different student clients, namely, items submitted by different students, and can also correspond to the same student client, namely, items submitted by the same student for different tasks.

The correction task items are related to the tasks submitted by the students, so in the embodiment, the acquisition of the correction task items is realized based on the third interface registered in the Gitlab service deployed by the correction page.

Specifically, a third interface registered in the Gitlab service deployed by the correction page is determined, and correction task items corresponding to the teacher client are synchronized to the teacher client through the call of the third interface. Namely, the third interface realizes the intercommunication of the correction task items between the Gitlab server and the teacher client.

Similarly, the registering means that the third interface is defined in the Gitlab server providing the Gitlab service, so that the Gitlab server knows that the third interface is used for transmitting the correction task item to the teacher client. That is, through the third interface definition, the Gitlab server knows: the data transmitted by the interface is a correction task item, and the destination of the data is a teacher client.

Alternatively, the intercommunication of the correction task items between the Gitlab server and the teacher client can be realized by the network server.

Referring to FIG. 12, in an exemplary embodiment, step 350 may include the steps of:

step 351, obtaining a correction task selection operation triggered by the correction task item corresponding to the student client from the correction task items displayed on the correction page.

As shown in fig. 11, based on the plurality of correction task entries 504 displayed on the correction page 503, the teacher can view brief information of all correction tasks, such as task submitters, task submission dates, task evaluations, task scores, etc., and can click on the corresponding correction task entry 5041, assuming that the teacher desires to perform task correction for one of the correction tasks without evaluation. Wherein, the clicking operation is regarded as the correction task selection operation.

Similarly, in the task submitting operation, the specific behavior of the correction task selecting operation may be different according to different input components (such as a touch screen, a mouse, a keyboard, and the like) configured in the terminal, and the detailed description is not repeated here.

Step 353, based on the correction task selection operation, obtaining the task data of the task corresponding to the selected correction task item.

Referring to fig. 5 and 11, when the teacher selects the correction task entry 5041 as shown in fig. 11, for the teacher's client, the task data related to the task corresponding to the correction task entry 5041 is obtained and displayed in the correction page 305 as shown in fig. 5.

As previously described, task data associated with the task submission operation is synchronized to the teacher client via a call through the first interface.

Based on this, the task data related to the task corresponding to the correction task item, that is, the task data related to the task submission operation, is substantially acquired from the local storage of the teacher client.

Step 355, according to the acquired task data, displaying the task difference submitted by the student client on the correction page.

In this embodiment, when the teacher arranges the task, the teacher provides the original data, for example, the source code, so that when the student submits the task, the student can perform corresponding operations, for example, insertion, deletion, addition, and the like, based on the original data, thereby making the difference between the task data related to the task submitted by the student and the original data.

The differential display refers to displaying on the correction page through different marks according to the difference between the original data and the task data. The mark may be a color, a symbol, or the like, and is not limited herein.

Specifically, as shown in fig. 13, the differentiated display process may include the following steps:

step 3551, obtaining original data from the database corresponding to the network classroom.

The original data is stored in the database corresponding to the network classroom as the teacher client accesses the network classroom, and therefore, the original data is obtained from the database corresponding to the network classroom.

Step 3553, comparing the original data with the task data to generate a differentiation result.

And a differentiation result for indicating a difference existing between the original data and the task data.

Step 3555, displaying the tasks submitted by the student client in the correction page according to the differentiation result.

Referring back to FIG. 5, the deleted data may be indicated by a red mark, such as 3061 in FIG. 5; for modified or added data, it is displayed by a green mark, as indicated by 3062 in FIG. 5.

Under the cooperation of the above embodiment, the tasks submitted by the students are better displayed to the teacher, so that the teacher can better perform task correction, and the efficiency of the correction process is further improved.

Referring to fig. 14, in an exemplary embodiment, the method as described above may further include the steps of:

step 610, when the client detects the operation, determining a fourth interface registered in the Gitlab service deployed by the Gitlab page.

The operation comprises the task submitting operation or the task correcting operation, and the Gitlab page comprises a task page or a correcting page.

Step 630, call the fourth interface, and trigger a notification push flow.

The notification is used for prompting a teacher that a newly submitted task exists or prompting a student that a batched task exists.

Similarly, the first interface and the fourth interface are used for realizing the intercommunication of the notification between the Gitlab server and the third-party system. The third-party system refers to a mailbox system, a short message system and the like which are connected with a user corresponding to the client.

And the registration of the fourth interface essentially means that the fourth interface is defined in a Gitlab server providing the Gitlab service so that the Gitlab server can push the notification to a third-party system. That is, through the fourth interface definition, the Gitlab server knows: the data transmitted by the interface is a notice, and the destination of the data is a third-party system.

That is, when the student client detects a task submission operation, it is known that the student has submitted the task, and then the fourth interface may be called, and based on the gillab service, a notification is pushed to a third-party system associated with the teacher, for example, a mail is sent to notify the teacher that a new submitted task exists.

For the teacher client, when the task correction operation is detected, it is known that the teacher has performed task correction, and then the fourth interface is called, and based on the gillab service, a notification is pushed to a third party system associated with the student, for example, a short message is sent to notify the student that the corrected task exists.

Under the effect of the embodiment, the notification mechanism of the online classroom is realized, even if a student or a teacher goes off-line, the fact that the teacher has approved the task or the student submits the task can be known in time, and the teaching experience of remote teaching is favorably improved.

Referring to fig. 15, in an exemplary embodiment, after the client accesses the web classroom presentation Gitlab page, the method as described above may further include the following steps:

step 710, if the Gitlab page is displayed in the network classroom accessed by the client for the first time, generating a corresponding account for the Gitlab service deployed by the Gitlab page.

And 730, establishing a binding relationship between the account corresponding to the Gitlab service deployed on the Gitlab page and the online classroom account corresponding to the online classroom.

And step 750, based on the established binding relationship, redisplaying the Gitlab page in the network classroom accessed by the client.

That is to say, the client needs to have an account corresponding to the Gitlab service to enjoy the Gitlab service provided by the Gitlab server, and the client needs to further perform binding between the account corresponding to the Gitlab service and the account corresponding to the web classroom if the client needs to enjoy the Gitlab service without departing from the web classroom.

As shown in fig. 16, after the instruction page jumps to the Gitlab page, if the Gitlab page with the Gitlab service deployed is first displayed, registration of the account corresponding to the Gitlab service is triggered, a binding relationship is established between the account corresponding to the Gitlab service and the account corresponding to the webclass, and then the Gitlab page is re-displayed, so that the client can enjoy the Gitlab service provided by the Gitlab server based on the displayed Gitlab page.

Referring to fig. 17, in an exemplary embodiment, step 730 may include the following steps:

step 731, determining a fifth interface registered in the Gitlab service deployed by the Gitlab page.

And similarly, the first interface and the fifth interface are used for realizing the intercommunication of the accounts corresponding to the Gitlab service between the Gitlab server and the network server. The network server side constructs a database corresponding to the network course.

And the registration of the fifth interface substantially means that the fifth interface is defined in a Gitlab server providing the Gitlab service, so that the Gitlab server transmits an account corresponding to the Gitlab service to a network server side. That is, through the fifth interface definition, the Gitlab server knows: the data transmitted by the interface is an account corresponding to the Gitlab service, and the destination of the data is a network server side.

And 733, calling the fifth interface, transmitting the account corresponding to the Gitlab service deployed on the Gitlab page to a network server side, and binding the account with the account corresponding to the network classroom.

Step 735, storing the binding relationship in the network server.

Therefore, the communication of the account number system between the Gitlab service and the online classroom is realized, and further, the communication of relationship chain data (such as task data and task correction results) between students and teachers in the online classroom to the deployed Gitlab service is facilitated, so that the whole correction process is coherent and convenient, and the improvement of the efficiency of the correction process is facilitated.

Referring to fig. 18, in an exemplary embodiment, before the interface is called, the method as described above may further include the following steps:

step 810, requesting the client to perform interface call query through the Gitlab service deployed by the Gitlab page.

The Gitlab page comprises a task page or a correction page, and the interfaces comprise a first interface, a second interface, a third interface, a fourth interface or a fifth interface.

The interface is registered in the Gitlab service to define the interface in the Gitlab server, so that the Gitlab server can acquire the data transmitted by the interface and the data destination.

Before calling an interface, it is necessary to query whether the called interface is allowed to be called by the client.

If the query result indicates that the interface is allowed to be called, then the jump is performed to step 830.

Otherwise, if the query result indicates that the interface is not allowed to be called, the calling of the interface is stopped.

For example, if the client does not register an account corresponding to the Gitlab service, the client cannot enjoy the Gitlab service provided by the Gitlab server, and at this time, the client is not allowed to call the interface.

Or the client registers an account corresponding to the Gitlab service, but the account corresponding to the Gitlab service is not bound with the network classroom corresponding to the network classroom, so that data intercommunication between the Gitlab service and the network classroom cannot be realized, and at this time, the interface is not allowed to be called.

Or, if the student does not purchase the corresponding course, the task submission is not allowed, the interface calling is also not allowed, and the teacher may not have the authority to modify the task submitted by the student or allow the interface calling.

Based on the above, as shown in fig. 19, the interface call query includes the following two aspects:

on the first hand, the account relation is inquired, namely whether the account corresponding to the Gitlab service has the account with the binding relation is inquired by calling the interface service provided by the network classroom.

If not, the query result indicates that the interface is not allowed to be called.

Otherwise, if so, continuing to perform the interface call query of the second aspect.

In a second aspect, a client is authenticated. The identity authentication means that whether a student has a submitting authority for submitting a task or whether a teacher has a correcting authority for correcting the task is checked.

If the client passes the identity authentication, the query result indicates that the interface is allowed to be called.

Otherwise, if the client fails the identity authentication, the query result indicates that the interface is not allowed to be called.

It should be noted that, in this embodiment, the execution sequence of the two aspects of the interface call query is not specifically limited, and the query of the second aspect may be executed first, and then the query of the first aspect may be executed.

And step 830, when the query result indicates that the interface is allowed to be called, calling the interface.

Through the process, the correctness of interface calling is fully guaranteed, the wrong interface calling in the correction process is avoided, and the efficiency of the correction process is effectively guaranteed.

The task synchronization process is described with reference to fig. 19, where the user may be a teacher or a student, and when the client running on the terminal held by the user for performing remote teaching is regarded as being connected to the online classroom, the task synchronization is started.

The terminal can be a smart phone, a personal computer, or the like, and correspondingly, the client can be a remote teaching client running on the smart phone, or a browser client running on the personal computer.

Based on the Gitlab page with the deployed Gitlab service, any correction operation performed by the user, including related operations of student submission tasks and related operations of teacher correction tasks, can be captured by the Gitlab page, and then data (such as task data and task correction results) related to the operations are stored in the Gitlab server and are uniformly managed by the Gitlab server.

Further, based on various interfaces registered in the Gitlab service deployed by the Gitlab page, the Gitlab server can synchronize the stored data to a database corresponding to a network classroom constructed by the network server in time.

Before data synchronization, interface calling query is carried out through interface service provided by a network classroom, and only if a query result indicates that the interface is allowed to be called, the Gitlab server allows data to be synchronized to a database and further synchronized to a client side, so that task synchronization is realized.

Through the process, no matter teachers or students enter the online classroom next time, the tasks can be found to be synchronous, for example, for teachers, newly submitted tasks are found, and for students, approved tasks are found, so that teachers and students can communicate better, and the teaching experience of remote teaching is greatly improved.

The following is an embodiment of the apparatus of the present invention, which can be used to perform the task synchronization method of the present invention. For details which are not disclosed in the embodiments of the apparatus of the present invention, reference is made to method embodiments of the task synchronization method according to the present invention.

Referring to FIG. 20, in an exemplary embodiment, a remote tutorial system 900 includes, but is not limited to: a student client 910 and a teacher client 930 accessing the network classroom.

The student client 910 is configured to determine, in a task page displayed in an accessed network classroom, a first interface registered in a Gitlab service deployed in the task page according to a detected task submission operation.

The student client 910 is further configured to invoke the first interface, and synchronize task data related to the task submitting operation to the teacher client.

The teacher client 930 is configured to display the tasks submitted by the student clients in a differentiated manner according to the task data in the correction page displayed in the accessed network classroom.

The teacher client 930 is further configured to perform task correction operation detection in the displayed task, and determine a second interface registered in the Gitlab service deployed in the correction page according to the detected task correction operation.

The teacher client 930 is further configured to invoke the second interface, and feed back a task modification result related to the task modification operation to the student client.

In an exemplary embodiment, the student client 910 further includes, but is not limited to: a request submitting module and a task page jumping module.

The request submitting module is used for receiving a task submitting request by the student client in a teaching page displayed in a network classroom accessed by the student client.

And the task page skipping module is used for skipping from the teaching page to the task page according to the task submitting request.

In an exemplary embodiment, the teacher client 930 further includes, but is not limited to: the device comprises a request receiving module and a correction page jumping module.

The request receiving module is used for receiving a task correction request by the teacher client in a teaching page displayed in a network classroom accessed by the teacher client.

And the correction page skipping module is used for skipping from the teaching page to the correction page according to the task correction request and displaying the correction task item.

In an exemplary embodiment, the batch page jump module includes, but is not limited to: a page jump unit and an item acquisition unit.

And the page jumping unit is used for responding to the task correcting request and jumping to the correcting page from the teaching page.

And the item acquisition unit is used for acquiring the correction task item corresponding to the teacher client and displaying the acquired correction task item in the correction page.

In an exemplary embodiment, the item acquisition unit includes, but is not limited to: an interface determination subunit and an entry synchronization subunit.

And the interface determining subunit is used for determining a third interface registered in the Gitlab service deployed by the correction page.

And the item synchronization subunit is used for calling the third interface and synchronizing the correction task items corresponding to the teacher client.

In an exemplary embodiment, the teacher client 930 further includes, but is not limited to: the system comprises an operation acquisition module, a task data acquisition module and a differentiation display module.

The operation acquisition module is used for acquiring the correction task selection operation triggered by the correction task item corresponding to the student client from the correction task item displayed on the correction page.

And the task data acquisition module is used for acquiring the task data of the task corresponding to the selected correction task item based on the correction task selection operation.

And the differentiation display module is used for differentially displaying the tasks submitted by the student client on the correction page according to the acquired task data.

In an exemplary embodiment, the differential display module includes, but is not limited to: the device comprises an original data acquisition unit, a difference comparison unit and a difference display unit.

The device comprises an original data acquisition unit, a database management unit and a database management unit, wherein the original data acquisition unit is used for acquiring original data from the database corresponding to the network classroom.

And the difference comparison unit is used for comparing the original data with the task data to generate a differentiation result.

And the difference display unit is used for displaying the tasks submitted by the student client in the correction page according to the difference result.

In an exemplary embodiment, the operation includes the task submitting operation or the task correcting operation, and the Gitlab page includes a task page or a correcting page.

The student client 910 or the teacher client 930 further include, but are not limited to: the device comprises an interface determining module and a notification triggering module.

And the interface determining module is used for determining a fourth interface registered in the Gitlab service deployed by the Gitlab page when the client detects the operation.

And the notification triggering module is used for calling the fourth interface and triggering a notification pushing process, and the notification is used for prompting a teacher that a newly submitted task exists or prompting a student that a batched task exists.

In an exemplary embodiment, the Gitlab page includes a task page or an endorsement page.

The student client 910 or the teacher client 930 further include, but are not limited to: the account binding module comprises an account generating module, an account binding module and a page display module.

And the account generation module is used for generating a corresponding account for the Gitlab service deployed by the Gitlab page if the Gitlab page is displayed in a network classroom accessed by the client for the first time.

And the account number binding module is used for establishing a binding relationship between an account number corresponding to the Gitlab service deployed on the Gitlab page and an account number corresponding to the network classroom.

And the page display module is used for redisplaying the Gitlab page in the network classroom accessed by the client based on the established binding relationship.

In an exemplary embodiment, the account binding module includes but is not limited to: the device comprises an interface determining unit, a binding unit and a storage unit.

The interface determining unit is used for determining a fifth interface registered in the Gitlab service deployed by the Gitlab page.

And the binding unit is used for calling the fifth interface, transmitting the account corresponding to the Gitlab service deployed on the Gitlab page to the database corresponding to the network classroom, and binding the account with the account corresponding to the network classroom in the database corresponding to the network classroom.

And the storage unit is used for storing the binding relationship in a database corresponding to the network classroom.

In an exemplary embodiment, the Gitlab page comprises a task page or an approval page and the interface comprises a first interface or a second interface.

The student client 910 or the teacher client 930 further include, but are not limited to: the interface calling query module and the interface calling module.

And the interface calling query module is used for requesting the client to carry out interface calling query through the Gitlab service deployed by the Gitlab page.

And the interface calling module is used for calling the interface when the query result indicates that the interface is allowed to be called.

In an exemplary embodiment, the interface call query module includes, but is not limited to: the system comprises a service calling unit, an account inquiry unit and an interface disabling unit.

The service calling unit is used for responding to a request for deploying the Gitlab service on the Gitlab page, and the client calls the interface service provided by the network classroom.

And the account number query unit is used for querying whether the account number corresponding to the Gitlab service initiating the request has the online classroom account number with the binding relationship through the called interface service. If not, the interface disabling unit is notified.

The interface disabling unit is used for indicating that the interface is not allowed to be called according to the query result.

In an exemplary embodiment, the interface call query module further includes, but is not limited to: an identity authentication unit and an interface calling module.

And the identity authentication unit is used for performing identity authentication of the client if the account corresponding to the Gitlab service initiating the request has the online classroom account with the binding relationship.

The interface calling module is used for allowing the interface to be called according to the inquiry result when the client passes the identity authentication.

It should be noted that, when the task synchronization device provided in the foregoing embodiment performs task synchronization processing, the division of the functional modules is merely illustrated as an example, and in practical applications, the functions may be distributed to different functional modules according to needs, that is, the internal structure of the task synchronization device is divided into different functional modules to complete all or part of the functions described above.

In addition, the embodiments of the task synchronization apparatus and the task synchronization method provided by the above embodiments belong to the same concept, and the specific manner in which each module executes operations has been described in detail in the method embodiments, and is not described herein again.

Referring to fig. 21, in an exemplary embodiment, an electronic device 1000 includes at least one processor 1001, at least one memory 1002, and at least one communication bus 1003.

Wherein the memory 1002 has computer readable instructions stored thereon, the processor 1001 reads the computer readable instructions stored in the memory 1002 through the communication bus 1003.

The computer readable instructions, when executed by the processor 1001, implement the task synchronization method in the embodiments described above.

In an exemplary embodiment, a computer readable storage medium has a computer program stored thereon, and the computer program, when executed by a processor, implements the task synchronization method in the above embodiments.

The above-mentioned embodiments are merely preferred examples of the present invention, and are not intended to limit the embodiments of the present invention, and those skilled in the art can easily make various changes and modifications according to the main concept and spirit of the present invention, so that the protection scope of the present invention shall be subject to the protection scope of the claims.

Claims (15)

1. A task synchronization method, adapted to a remote teaching system including clients accessing an online classroom, the clients including a student client and a teacher client, the method comprising:

the student client determines a first interface registered in a Gitlab service deployed in a task page according to the detected task submitting operation in the task page displayed in the accessed network classroom;

calling the first interface, and synchronizing task data related to the task submitting operation to the teacher client;

the teacher client displays the tasks submitted by the student clients according to the task data in the correction page displayed in the accessed network classroom;

performing task correction operation detection in the displayed task, and determining a second interface registered in a Gitlab service deployed by the correction page according to the detected task correction operation;

and calling the second interface, and feeding back a task correcting result related to the task correcting operation to the student client.

2. The task synchronization method according to claim 1, wherein before the student client determines the first interface registered in the Gitlab service deployed in the task page according to the detected task submission operation in the task page displayed in the accessed network classroom, the method further comprises:

in a teaching page displayed in a network classroom accessed by the student client, the student client receives a task submission request;

and jumping to the task page from the teaching page according to the task submitting request.

3. The task synchronization method of claim 1, wherein the teacher client displays the tasks submitted by the student clients according to the task data in a correction page presented in the accessed web classroom, the method further comprising:

in a teaching page displayed in a network classroom accessed by the teacher client, the teacher client receives a task correction request;

and jumping to the correction page from the teaching page according to the task correction request, and displaying correction task items.

4. The task synchronization method of claim 3, wherein the jumping from the teaching page to the correcting page for displaying the correcting task items according to the task correcting request comprises:

responding to the task correcting request, and jumping to the correcting page from the teaching page;

and acquiring a correction task item corresponding to the teacher client, and displaying the acquired correction task item in the correction page.

5. The task synchronization method of claim 4, wherein the obtaining an approval task entry corresponding to the teacher client comprises:

determining a third interface registered in a Gitlab service deployed by the correction page;

and calling the third interface, and synchronizing the correction task item corresponding to the teacher client.

6. The task synchronization method of claim 1, wherein the displaying, by the teacher client, the tasks submitted by the student clients according to the task data in a correction page presented in the accessed web classroom comprises:

acquiring a correction task selection operation triggered by a correction task item corresponding to the student client from the correction task item displayed on the correction page;

based on the correction task selection operation, acquiring the task data of the task corresponding to the selected correction task item;

and displaying the task submitted by the student client on the correction page in a differentiated manner according to the acquired task data.

7. The task synchronization method according to claim 6, wherein the differentially displaying the task submitted by the student client on the correction page according to the acquired task data comprises:

acquiring original data from the database corresponding to the network classroom;

comparing the original data with the task data to generate a differentiation result;

and displaying the tasks submitted by the student client in the correction page according to the differentiation result.

8. The task synchronization method of claim 1, wherein an operation comprises the task submission operation or the task modification operation, and a Gitlab page comprises a task page or a modification page;

the method further comprises the following steps:

when the client detects the operation, determining a fourth interface registered in a Gitlab service deployed by the Gitlab page;

and calling the fourth interface, and triggering a notification pushing process, wherein the notification is used for prompting a teacher that a newly submitted task exists or prompting a student that a batched task exists.

9. A task synchronization method according to claim 1, wherein a Gitlab page comprises a task page or a correction page;

after the client accesses the web classroom display Gitlab page, the method further comprises the following steps:

if the Gitlab page is displayed in a network classroom accessed by the client for the first time, generating a corresponding account number for the Gitlab service deployed by the Gitlab page;

establishing a binding relationship between an account corresponding to a Gitlab service deployed on the Gitlab page and an account corresponding to the network classroom;

and based on the established binding relationship, re-displaying the Gitlab page in the network classroom accessed by the client.

10. The task synchronization method according to claim 9, wherein the establishing of the binding relationship between the account corresponding to the Gitlab service deployed on the Gitlab page and the account corresponding to the web classroom comprises:

determining a fifth interface registered in the Gitlab service deployed by the Gitlab page;

calling the fifth interface, transmitting an account corresponding to the Gitlab service deployed on the Gitlab page to the database corresponding to the network classroom, and binding the account with the account corresponding to the network classroom in the database corresponding to the network classroom;

and storing the binding relationship in a database corresponding to the network classroom.

11. A task synchronization method according to any one of claims 1 to 10, wherein the Gitlab page comprises a task page or a correction page, and the interface comprises a first interface or a second interface;

before the interface is called, the method further comprises:

requesting the client to perform interface calling query through the Gitlab service deployed by the Gitlab page;

and when the query result indicates that the interface is allowed to be called, calling the interface.

12. The task synchronization method of claim 11, wherein requesting the client to perform an interface call query through a Gitlab service deployed by the Gitlab page comprises:

responding to a request of deploying Gitlab service by the Gitlab page, and calling interface service provided by the network classroom by the client;

inquiring whether an account corresponding to the Gitlab service initiating the request has an online classroom account with a binding relationship or not through the called interface service;

if not, the query result indicates that the interface is not allowed to be called.

13. The task synchronization method of claim 12, wherein the requesting the client to perform an interface call query via the Gitlab service deployed by the Gitlab page further comprises:

if the account corresponding to the Gitlab service initiating the request has the online classroom account with the binding relationship, performing identity authentication of the client;

and when the client passes the identity authentication, the query result indicates that the interface is allowed to be called.

14. The task synchronization method of claim 11, wherein the interface performs interface definition in a Gitlab server by registering in a Gitlab service, so that the Gitlab server knows the data transmitted by the interface and the destination of the data.

15. A remote teaching system, which comprises a student client and a teacher client connected to an online classroom, wherein,

the student client is used for determining a first interface registered in a Gitlab service deployed in a task page according to the detected task submitting operation in the task page displayed in the accessed network classroom;

the student client is also used for calling the first interface and synchronizing task data related to the task submitting operation to the teacher client;

the teacher client is used for displaying tasks submitted by the student clients in a differentiation mode according to the task data in a correction page displayed in the accessed network classroom;

the teacher client is further used for performing task correction operation detection in the displayed tasks and determining a second interface registered in the Gitlab service deployed in the correction page according to the detected task correction operation;

the teacher client is further used for calling the second interface and feeding back a task correcting result related to the task correcting operation to the student client.

Images