Below is a sample code from one of my Solana DApps which generates a course completion certificate.

use solana_program::{
    account_info::{next_account_info, AccountInfo},
    entrypoint,
    entrypoint::ProgramResult,
    msg,
    program_error::ProgramError,
    pubkey::Pubkey,
    program_pack::{Pack, IsInitialized},
    sysvar::{rent::Rent, Sysvar},
};
use std::mem::size_of;

// Define the state struct for the educational certificate
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Certificate {
    pub name: String,
    pub course: String,
    pub date: String,
    pub is_initialized: bool,
}

// Define the program ID for the certificate generator
const PROGRAM_ID: [u8; 32] = [0cb27085d05b2737f1cab35e7ce1683fcd17e2121511135af650fe627ab36bc7];

// Define the entry point for the certificate generator
#[entrypoint]
pub fn generate_certificate(
    program_id: &Pubkey,
    accounts: &[AccountInfo],
    name: String,
    course: String,
    date: String,
) -> ProgramResult {
    // Ensure that the program ID provided matches the expected value
    if program_id != &Pubkey::from_bytes(&PROGRAM_ID) {
        return Err(ProgramError::IncorrectProgramId);
    }

    // Parse the accounts provided
    let accounts_iter = &mut accounts.iter();
    let certificate_account = next_account_info(accounts_iter)?;

    // Ensure that the certificate account is owned by this program
    if certificate_account.owner != program_id {
        return Err(ProgramError::IncorrectProgramId);
    }

    // Ensure that the certificate account is not already initialized
    if Certificate::is_initialized(&certificate_account.data.borrow()) {
        return Err(ProgramError::AccountAlreadyInitialized);
    }

    // Get the rent sysvar to determine the minimum balance for the certificate account
    let rent = &Rent::from_account_info(next_account_info(accounts_iter)?)?;

    // Determine the minimum balance required for the certificate account
    let certificate_size = size_of::<Certificate>();
    let minimum_balance = rent.minimum_balance(certificate_size);

    // Check that the certificate account has sufficient balance
    if certificate_account.lamports() < minimum_balance {
        return Err(ProgramError::InsufficientFunds);
    }

    // Initialize the certificate account with the provided data
    let mut certificate_data = certificate_account.data.borrow_mut();
    let mut certificate = Certificate::unpack_unchecked(&certificate_data)?;

    certificate.name = name;
    certificate.course = course;
    certificate.date = date;
    certificate.is_initialized = true;

    Certificate::pack(certificate, &mut certificate_data)?;

    Ok(())
}

This is still a "work in progress".

The code is not working yet as it still needs to be modified, secured, and pay to the Solana blockchain to run the DApp, however, it shows some Rust code on the Solana blockchain.