How to Quickly Create a PHP Developer Contract using Google Artificial Intelligence Generative Language API - PHP Markdown Parser package blog

In this article you will learn:

2. What a Developer Contract Should Contain

3. How to Create a Developer Contract without Hiring a Lawyer

4. How to Download or Install the Markdown Parser and Markup Parser Classes using PHP Composer

1. Why You Need to Have a Contract Before Start Working For a Customer

A contract is good to do before you work for a customer so you can read the agreement later in case you need to remember what you agreed with the customer so both sides can accomplish what the customer and the developer requested.

Some people use contracts to sue the other party when they do not do what was agreed.

I always advise the peaceful route to dialog and renegotiate the contract rather than using the justice system when there is a disagreement.

2. What a Developer Contract Should Contain

A developer contract usually includes clauses that define the work that is agreed to be done, the amount of money to be paid by the customer to the developer, the amount of time that is expected to take to do the work, resources that are necessary to implement the project and the customer should pay separately, what happens if you discover that the project needs to change due to unexpected difficulties.

Be aware that some customers expect that the projects be executed in a specific time frame that may not be realistic. Therefore, it is good that the developers ask for a fixed amount of money by month if the project is expected to take more than one month to be finished.

It is also good to ask that if the project takes more time to be finished than expected, the customer also should pay for the time it took because everybody has a cost that needs to be paid.

3. How to Create a Developer Contract without Hiring a Lawyer

Writing a good contract requires good knowledge of laws and good practices that may apply in the countries where the developer and the customer are located according to the scope of the work.

A significant number of developers are not aware of these laws and good practices. Fortunately, nowadays, some tools can assist developers in creating work contracts just by using these tools.

One of those tools is the Google Generative Language API. This tool uses artificial intelligence to provide template text documents that developers can use to base the contracts they need to sign with their customers.

You need to follow several steps to use this API and generate a helpful contract.

3.1 Get an API Key to Use the Google Generative Language API

The first step is to generate an API key to develop a script called the Google Generative Language API.

To manage API keys, you can create this API key on the Google Maker Suite page.

First, you must create a Google API project or use an API project you already made.

Then, copy the generated API key in your script called the Google Generative Language API.

3.2 Write Code to Call the Google Generative Language API to Generate the Contract

The Google Generative Language API can take a request as a text prompt and then return a response with text documents that fulfill the demand. The returned text documents are in the Markdown format.

The example script below uses the Markdown parser class to parse the text returned by the Google Generative Language API. Then, it uses the Markup parser class to generate HTML representing the exact text in HTML that you can use to display in Web pages.

This script is just sample of the complete script to generate PHP developer contracts that you can view or download here.

Obtain an API key from Google Maker suite site and assign the $api_key variable.

    $api_key = '';
   
    if($api_key === '')
    {
        die('Please go to Google Maker suite site to obtain an API key: https://makersuite.google.com/app/apikey');
    }

The prompt is the request that you want Google generative API to perform. You may change this prompt text according to what you want to be generated.

    $prompt = "Write a PHP developer contract";

These are template variable values that will be use to replace in the text generated by the Google generative API.

    $client_name = 'Customer company name';
    $client_address = 'Customer company address';
    $developer_email_address = 'mlemos@acm.org';
    $developer_name = 'Manuel Lemos';
    $developer_address = 'Developer company address';
    $amount = 'USD $1000';

Here we send a HTTP request to the Google Generative Language API with the API key that was obtained in the previous step.

    $request = new stdClass;
    $request->prompt = new stdClass;
    $request->prompt->text = $prompt;
    $opts = array(
        'http'=>array(
            'method'=>"POST",
            'header'=>"Content-Type: application/json\r\n",
            'content'=>json_encode($request)
        )
    );

    $context = stream_context_create($opts);

    $generated_php_developer_contract_template_json = file_get_contents('https://generativelanguage.googleapis.com/v1beta3/models/text-bison-001:generateText?key='.$api_key, false, $context);
   
    if($generated_php_developer_contract_template_json === false)
    {
        $error = error_get_last();
        die('Could not access the Google Generative language API: '.$error['message']);
    }

Here we decode the JSON response and check if the API returned candidate texts as response to the prompt request. In this example we only consider the first candidate text response.

    $generated_php_developer_contract_template = json_decode($generated_php_developer_contract_template_json);
   
    if(count($generated_php_developer_contract_template->candidates) === 0)
    {
        die('Google generative API returned no results for the request of: '.$prompt);
    }
    /*
     *
     * Google generative API may generate multiple candidates for the
     * requested text. Here we are considering just the first candidate.
     *
     */

    $generated_php_developer_contract_template_markup = $generated_php_developer_contract_template->candidates[0]->output;

Replace template variable values to adjust the generated text according to your needs.

    $generated_php_developer_contract_markup = str_replace(array(
            '[Client Name]',
            '[Address]',
            '[Email Address]',
            '[PHP Developer Name]',
            '[Address]',
            '[amount]',
           
            '[Client Address]',
            '[Developer Name]',
            '[Developer Address]',
            '[Client Signature]',
            '[Client Printed Name]',
            '[Developer Signature]',
            '[Developer Printed Name]',
        ), array(
            $client_name,
            $client_address,
            $developer_email_address,
            $developer_name,
            $developer_address,
            $amount,
           
            $client_address,
            $developer_name,
            $developer_address,
            $client_name,
            $client_name,
            $developer_name,
            $developer_name
        ),
        $generated_php_developer_contract_template_markup
    );

The resulting text is in the Markdown format. If you want to use the text in a HTML page or another format, you need to convert the text to that format.

    $markdown=new markdown_parser_class;
    $markdown->track_lines = 1;
    $parameters=array(
        'Data'=>$generated_php_developer_contract_markup
    );

    if(($success = $markdown->StartParsing($parameters)))
    {
        $markup = new markup_parser_class;
        $html = '';
        do
        {
            if(!($success = $markdown->Parse($end, $elements)))
                break;
            foreach($elements as $element)
            {
                if(!($success = $markup->RewriteElement($element, $element_html)))
                    break 2;
                $html .= $element_html;
            }
        }
        while(!$end);
        if($success)
            $success = $markdown->FinishParsing();
    }
    echo '<html><head><title>Generated PHP developer contract</title></head><body>';
    if($success)
    {
        echo $html;
    }
    else
    {
        echo '<h1>Markdown parsing error: '.HtmlSpecialChars($markdown->error).' at position '.$markdown->error_position;
        if($markdown->track_lines
        && $markdown->GetPositionLine($markdown->error_position, $line, $column))
            echo ' line '.$line.' column '.$column;
        echo "</h1>\n";
    }
    for($warning = 0, Reset($markdown->warnings); $warning < count($markdown->warnings); Next($markdown->warnings), $warning++)
    {
        $w = Key($markdown->warnings);
        echo '<p>Warning: ', HtmlSpecialChars($markdown->warnings[$w]), ' at position ', $w;
        if($markdown->track_lines
        && $markdown->GetPositionLine($w, $line, $column))
            echo ' line '.$line.' column '.$column;
        echo "</p>\n";
    }
    echo '</body></html>';

3.3 How to Address the Limitations of the Generated Contracts to Make them More Suited for Your Needs

There are a few details that you need to be aware when you use the Google Generative Language API in the way that is shown in the example script above.

One detail that each time you call the API, it may return a different response to the same request. It is up to you to pick one response and stick to it.

The response texts may be obtained by Google from other sites that were produced by other people. The response texts may be subject to licenses. Some licenses may require the payment of licensing fees.

If you want to use these texts as they are returned by Google API, it is better that you respect the original license or at least ask explicit permission from the original text author. In that case, the API call responses mention the URL of the pages from where the response text was obtained.

If you do not want to license the response texts, you can still use them to learn and create your own contracts based on what you learned.

4. How to Download or Install the Markdown Parser and Markup Parser Classes using PHP Composer

The example script above uses the markdown parser and the markup parser classes. You can download these packages or install them using PHP Composer.

Instructions to download or install these packages with PHP Composer can be found on the respective pages for the Markup parser and the Markdown parser packages.