ASP.NET

// Load the SMTP Credentials
using (var credentials = SendGmailAsync.Create_GoogleCredentials(ms))
{
    var result = await SendGmailAsync.Send_GmailAsync(await credentials, message, 5);
    SendGmailAsync.ProcessSendResult(model, result);
}

public static async Task<UserCredential> Create_GoogleCredentials(MAILSERVER ms)
{
    var secrets = new Google.Apis.Auth.OAuth2.ClientSecrets
    {
        ClientId = ms.OAuthCredentials.ClientId,
        ClientSecret = ms.OAuthCredentials.ClientSecret
    };

    var googleCredentials = await GoogleWebAuthorizationBroker.AuthorizeAsync(
        secrets,
        new[] { GmailService.Scope.MailGoogleCom, GmailService.Scope.GmailSend },
        ms.AccountName,
        CancellationToken.None
    );

    if (googleCredentials.Token.IsExpired(SystemClock.Default))
    {
        await googleCredentials.RefreshTokenAsync(CancellationToken.None);
    }

    return googleCredentials;

}

public static async Task<ServiceAccountCredential> Create_GoogleCredentialsWithAccessToken(MAILSERVER ms)
{
    var certBuffer = File.ReadAllBytes("projectName-xxxxxxxxxx.p12");
    var certificate = new X509Certificate2(certBuffer, "notasecret", X509KeyStorageFlags.Exportable);
    var serviceAccountEmail = "xxxxxxxxxx-xxxxxx.iam.gserviceaccount.com";
    var userAccountEmail = "xxx@xxxxxx.com";
    var credential = new ServiceAccountCredential(new ServiceAccountCredential.Initializer(serviceAccountEmail)
    {
        User = userAccountEmail,
        Scopes = new[] { GmailService.Scope.MailGoogleCom }
    }.FromCertificate(certificate));

    if (await credential.RequestAccessTokenAsync(CancellationToken.None))
    {
        var service = new GmailService(
            new Google.Apis.Services.BaseClientService.Initializer()
            {
                HttpClientInitializer = credential
            }
        );
    }

    return credential;
}

public static async Task<SendEmailCompletedEventArgs> Send_GmailServiceAsync(ServiceAccountCredential serviceCredentials, MimeMessage message, int retryCount)
{
    var currentTry = 0;
    while ((currentTry < retryCount))
    {
        try
        {
            using (var client = new SmtpClient())
            {
                client.Connect("smtp.gmail.com", 587, SecureSocketOptions.StartTls);
                client.AuthenticationMechanisms.Remove("XOAUTH2");
                var oauth2 = new SaslMechanismOAuth2(serviceCredentials.User, serviceCredentials.Token.AccessToken);
                client.Authenticate(oauth2);

                await client.SendAsync(message);
                client.Disconnect(true);
            }

            return new SendEmailCompletedEventArgs(null, false, null, currentTry);
        }
        catch (Exception ex)
        {
            currentTry++;
            if ((currentTry >= retryCount))
            {
                return new SendEmailCompletedEventArgs(ex, true, null, currentTry);
            }
        }

    }

    //  Code should never reach here, but without this line you'll get a BC42105 warning:
    return new SendEmailCompletedEventArgs(null, true, null, currentTry);
}

using (var credentials = SendGmailServiceP12Async.Create_GoogleCredentialsWithAccessToken(ms))
{
    var result = await SendGmailServiceP12Async.Send_GmailServiceAsync(await credentials, message, 5);
    SendGmailServiceP12Async.ProcessSendResult(model, result);
}

public static async Task<ServiceAccountCredential> Create_GoogleCredentialsWithAccessToken(MAILSERVER ms)
{
    ServiceAccountCredential credentials = null;<br />
    var serviceStream = await File.ReadAllTextAsync(ms.GoogleServiceFile);
    var parameters = new NewtonsoftJsonSerializer().Deserialize<GoogleServiceApi>(serviceStream);

    // Proceed as normal loading the credentials. 
    using (var stream = new FileStream(ms.GoogleServiceFile, FileMode.Open, FileAccess.Read))
    {
        ServiceAccountCredential original = (ServiceAccountCredential)
        GoogleCredential.FromStream(stream).UnderlyingCredential;

        var initializer = new ServiceAccountCredential.Initializer(original.Id)
        {
            User = parameters.user,
            ProjectId = parameters.project_id,
            Key = original.Key,
            Scopes = new[] { GmailService.Scope.MailGoogleCom, GmailService.Scope.GmailSend }
        };
        credentials = new ServiceAccountCredential(initializer);

        if (await credentials.RequestAccessTokenAsync(CancellationToken.None))
        {
            var service = new GmailService(
                new BaseClientService.Initializer()
                {
                    HttpClientInitializer = credentials
                }
            );
        }
    }

    return credentials;
}

public static async Task<SendEmailCompletedEventArgs> Send_GmailServiceAsync(ServiceAccountCredential serviceCredentials, MimeMessage message, int retryCount)
{
    var currentTry = 0;
    while ((currentTry < retryCount))
    {
        try
        {
            using (var client = new SmtpClient())
            {
                client.Connect("smtp.gmail.com", 587, SecureSocketOptions.StartTls);

                var oauth2 = new SaslMechanismOAuth2(serviceCredentials.User, serviceCredentials.Token.AccessToken);
                client.Authenticate(oauth2);

                await client.SendAsync(message);
                client.Disconnect(true);
            }

            return new SendEmailCompletedEventArgs(null, false, null, currentTry);
        }
        catch (Exception ex)
        {
            currentTry++;
            if ((currentTry >= retryCount))
            {
                return new SendEmailCompletedEventArgs(ex, true, null, currentTry);
            }
        }

    }

    //  Code should never reach here, but without this line you'll get a BC42105 warning:
    return new SendEmailCompletedEventArgs(null, true, null, currentTry);
}

public class GoogleServiceApi
{
    public string type { get; set; }
    public string user { get; set; }
    public string project_id { get; set; }
    public string private_key_id { get; set; }
    public string private_key { get; set; }
    public string client_email { get; set; }
    public string client_id { get; set; }
    public string auth_uri { get; set; }
    public string token_uri { get; set; }
    public string auth_provider_x509_cert_url { get; set; }
    public string client_x509_cert_url { get; set; }
}

Bartt_dmr wrote:

sql = "INSERT INTO tre_Eventos (Id_Curso, DataEvento) VALUES ('" & ddlCursos.SelectedValue & "', '" & endDate & "')"

Const sql As String = "INSERT INTO tre_Eventos (ID_Curso, DataEvento) VALUE (@ID_Curso, @DataEvento)"

Using conexao As New SqlConnection(strConn)
    conexao.Open()
    
    Using transaction As SqlTransaction = conexao.BeginTransaction()
        Using cmd As New SqlCommand(sql, conexao)
            cmd.Transaction = transaction
            cmd.Parameters.AddWithValue("@ID_Curso", ddlCursos.SelectedValue)
            
            Dim pDate As New SqlParameter("@DataEvento", SqlDbType.DateTime)
            cmd.Parameters.Add(pDate)
            
            Dim currDate As Date = startDate
            Do While currDate < endDate
                pDate.Value = currDate
                cmd.ExecuteNonQuery()
                currDate = currDate.AddDays(7)
            Loop
        End Using
        
        transaction.Commit()
    End Using
End Using

@Html.DropDownListFor(model => model.Country, ViewBag.state as List<SelectListItem>, { @id="ddlCountry", @class="YourCSSClassName" })

$("#ddlCountry").change(function () {

});

<div class="form-group">
    @Html.LabelFor(model => model.Country, htmlAttributes: new { @class = "control-label col-md-2" })
    <div class="col-md-10">
        @Html.DropDownListFor(model => model.Country, ViewBag.state as List<SelectListItem>
    , new {@id ="ddlCountry", @class = "form-control" })

<div class="form-group">
    @Html.LabelFor(model => model.City, htmlAttributes: new { @class = "control-label col-md-2" })
    <div class="col-md-10">
        @Html.DropDownListFor(model => model.City, new SelectList(string.Empty, "Value", "Text"), "--Select City--", 
       new {@id ="ddlCity", @class = "form-control" })

$(document).ready(function () {

        $("#ddlCountry").change(function () {
            $("#ddlCity").empty();
            $.ajax({
                type: 'POST',
                url: '@Url.Action("GetCity")',
                dataType: 'json',
                data: { id: $("#ddlCountry").val() },
                success: function (city) {

                    $.each(city, function (i, city) {
                        $("#ddlCity").append('<option value="' + city.Value + '">'+ city.Text + '</option>');

                    });
                },
                error: function (ex) {
                    alert('Failed.' + ex);
                }
            });
            return false;
        })
    });

public void Details ()
        {
            var model = db.GetUniversities().ToList();
            List<SelectListItem> li = new List<SelectListItem>();
            li.Add(new SelectListItem { Text = "Please select Country",Value="0"});
            foreach (var item in model)
            {
                li.Add(new SelectListItem { Text = item.Country, Value = item.Id.ToString()});
                ViewBag.state = li;
            }
        }
        [HttpPost]
        public JsonResult GetCity (int id)
        {
            var ddlCity = db.GetUniversities().Where(x => x.Id == id).ToList();
            List<SelectListItem> licities = new List<SelectListItem>();

            licities.Add(new SelectListItem { Text = "--Select City--", Value = "0" });

            if (ddlCity != null)
            {
                foreach (var x in ddlCity)
                {
                    licities.Add(new SelectListItem { Text = x.City, Value = x.Id.ToString() });
                }
            }
            return Json(new SelectList(licities, "Text", "Value"));