public static IList <string> ListFolders(ModelGoogleDrive _googleDrive)
{
List <string> lista = new List <string>();
using (var servico = InitGDriveService(_googleDrive))
{
var request = servico.Files.List();
request.Fields = "files(id, name)";
//request.Q = "mimeType='application/vnd.google-apps.folder'";
// request.Q = "'17CYl9ni0xJEERcMZeKalLZ5D3Kp-vjw4' in parents";
// request.Q = $"name contains '{folderName}'";
//request.Spaces = "Srv Backup DataBases";
var resultado = request.Execute();
var arquivos = resultado.Files;
if (arquivos != null && arquivos.Any())
{
foreach (var arquivo in arquivos)
{
lista.Add(arquivo.Name + " " + arquivo.Id);
}
}
servico.Dispose();
}
return(lista);
}
public static async Task <IList <string> > ListFilesInFolder(ModelGoogleDrive _googleDrive /*, string folderId*/)
{
List <string> lista = new List <string>();
using (var servico = InitGDriveService(_googleDrive))
{
var request = servico.Files.List();
request.Fields = "files(id, name, createdTime, modifiedTime, size)";
request.Q = $"'{_googleDrive.FolderId}' in parents";
var resultado = await request.ExecuteAsync();
var arquivos = resultado.Files;
if (arquivos != null && arquivos.Any())
{
foreach (var arquivo in arquivos)
{
lista.Add(arquivo.Name + " " + arquivo.Id + " " + arquivo.CreatedTime + " " + arquivo.ModifiedTime + " " + arquivo.Size + "<br>");
}
}
}
return(lista);
}
public static async Task <string> GetToken(ModelGoogleDrive _googleDrive)
{
try
{
// Erro ao descobrir quem é GoogleToken.GetWithRSA256
//var personalToken = await GoogleToken.GetWithRSA256(_googleDrive.CredentialFileName);
string postUri = "https://oauth2.googleapis.com/token";
var parameters = new Dictionary <string, string>();
parameters["grant_type"] = "urn:ietf:params:oauth:grant-type:jwt-bearer";
// parameters["assertion"] = personalToken;
//var values = new List<KeyValuePair<string, string>>();
//values.Add(new KeyValuePair<string, string>("grant_type", "urn:ietf:params:oauth:grant-type:jwt-bearer"));
//values.Add(new KeyValuePair<string, string>("assertion", personalToken));
// var content = new FormUrlEncodedContent(values);
var streamResult = await client.PostAsync(postUri, new FormUrlEncodedContent(parameters));
var contents = await streamResult.Content.ReadAsStringAsync();
return(contents);
}
catch (Exception err)
{
throw err;
}
}
public async Task <string> ExemploGoogle(string _fileName, string _path, ModelGoogleDrive _googleDrive, string _folderId)
{
try
{
string postUri = "https://www.googleapis.com/upload/drive/v3/files";
var responseToken = await CallManager.GetToken(_googleDrive);
string _bearerToken = responseToken.Substring(17, 219);
client.DefaultRequestHeaders.Add("Authorization", "Bearer " + _bearerToken);
var request = new HttpRequestMessage()
{
Method = HttpMethod.Post,
RequestUri = new Uri(postUri)
};
request.Properties.Add("uploadType", "resumable");
//var fileToUpload = new Google.Apis.Drive.v3.Data.File()
//{
// Name = _fileName,
// MimeType = MimeTypesMap.GetMimeType(System.IO.Path.GetExtension(_path)),
// Parents = new List<string>
// {
// _folderId
// }
//};
byte[] byteArray = System.IO.File.ReadAllBytes(_path + _fileName);
MemoryStream stream = new MemoryStream(byteArray);
var length = stream.Length.ToString();
StreamContent sc = new StreamContent(stream);
//sc.Headers.Add("Content-Type", "application/octet-stream");
//sc.Headers.Add("Content-Length", length);
request.Content = sc;
var streamResult = await client.SendAsync(request);
//var response = client.PostAsync(postUri, sc);
return(await streamResult.Content.ReadAsStringAsync());
}
catch (Exception err)
{
throw err;
}
finally
{
//client.Dispose();
}
}
public static ModelGoogleDrive LoadSetting(IConfiguration configuration)
{
ModelGoogleDrive settings = new ModelGoogleDrive();
settings.GoogleDriveAccountMail = configuration.GetSection("Settings").GetSection("GoogleDriveAccountMail").Value;
settings.FolderId = configuration.GetSection("Settings").GetSection("FolderId").Value;
settings.CredentialFileName = configuration.GetSection("Settings").GetSection("CredentialFileName").Value;
settings.GoogleAccountId = configuration.GetSection("Settings").GetSection("GoogleAccountId").Value;
settings.ApiKey = configuration.GetSection("Settings").GetSection("ApiKey").Value;
return(settings);
}
public static async Task <string> Upi(string _fileName, string _path, ModelGoogleDrive _googleDrive, string _folderId)
{
try
{
// 2. Create the url
string postUri = "https://www.googleapis.com/drive/v3/files?uploadType=media";
//string filename = "myFile.png";
var response = await CallManager.GetToken(_googleDrive);
string _bearerToken = response.Substring(17, 219);
// In my case this is the JSON that will be returned from the post
string result = "";
using (var formContent = new MultipartFormDataContent("NKdKd9Yk"))
{
formContent.Headers.ContentType.MediaType = "multipart/form-data";
// 3. Add the filename C:\\... + fileName is the path your file
Stream fileStream = System.IO.File.OpenRead(_path + _fileName);
formContent.Add(new StreamContent(fileStream), _fileName, _fileName);
using (var client = new HttpClient())
{
// Bearer Token header if needed
client.DefaultRequestHeaders.Add("Authorization", "Bearer " + _bearerToken);
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("multipart/form-data"));
try
{
// 4.. Execute the MultipartPostMethod
var message = await client.PostAsync(postUri, formContent);
// 5.a Receive the response
result = await message.Content.ReadAsStringAsync();
}
catch (Exception ex)
{
// Do what you want if it fails.
throw ex;
}
}
}
return(result);
}
catch (Exception ex)
{
return(ex.Message);
}
}
public async Task <IActionResult> GetFilesInFolder()
{
try
{
ModelGoogleDrive googleDrive = new ModelGoogleDrive();
googleDrive = Helpers.HelperGoogleDrive.LoadSetting(_configuration);
var result = await ServicesCeltaWare.UtilitariosInfra.GoogleApiStandard.CallManager.ListFilesInFolder(googleDrive);
return(Ok(result));
}
catch (Exception err)
{
return(BadRequest(err.Message));
}
}
public async Task <IActionResult> TesteGetTokenGoogle()
{
try
{
ModelGoogleDrive googleDrive = new ModelGoogleDrive();
googleDrive = Helpers.HelperGoogleDrive.LoadSetting(_configuration);
var result = await ServicesCeltaWare.Security.GoogleToken.GetWithRSA256(googleDrive.CredentialFileName);
return(Ok(result));
}
catch (Exception err)
{
return(BadRequest(err.Message));
}
}
public async Task <IActionResult> GetAllFolders()
{
try
{
ModelGoogleDrive googleDrive = new ModelGoogleDrive();
googleDrive = Helpers.HelperGoogleDrive.LoadSetting(_configuration);
var result = await CallManager.GetAllFoldersService(googleDrive);
return(Ok(result));
}
catch (Exception err)
{
return(BadRequest(err.Message));
}
}
public void TestApiKey(ModelGoogleDrive _googleDrive)
{
using (var servico = InitGDriveServiceWhithKey(_googleDrive))
{
var request = servico.Files.List();
request.Fields = "files(id, name)";
//request.Q = "mimeType='application/vnd.google-apps.folder'";
// request.Q = "'17CYl9ni0xJEERcMZeKalLZ5D3Kp-vjw4' in parents";
// request.Q = $"name contains '{folderName}'";
//request.Spaces = "Srv Backup DataBases";
var resultado = request.Execute();
var arquivos = resultado.Files;
servico.Dispose();
}
}
private static Google.Apis.Drive.v3.DriveService InitGDriveServiceWhithKey(ModelGoogleDrive _googleDrive)
{
try
{
Google.Apis.Drive.v3.DriveService service = new Google.Apis.Drive.v3.DriveService(new BaseClientService.Initializer()
{
ApplicationName = "ServicesCeltaInfra",
ApiKey = _googleDrive.ApiKey
});
return(service);
}
catch (Exception err)
{
HelperLogs.WriteLog(err.Message + "\br" + err.StackTrace);
throw err;
}
}
public async Task <IActionResult> GetGoogleToken()
{
try
{
ModelGoogleDrive googleDrive = new ModelGoogleDrive();
googleDrive = Helpers.HelperGoogleDrive.LoadSetting(_configuration);
var response = await CallManager.GetToken(googleDrive);
string onlyToken = response.Substring(17, 220);
return(Ok(onlyToken));
}
catch (Exception err)
{
return(BadRequest(err.Message));
throw err;
}
}
public static async Task <string> TesteUp(string _fileName, string _path, ModelGoogleDrive _googleDrive, string _folderId)
{
try
{
string postUri = "https://www.googleapis.com/upload/drive/v3/files?uploadType=media";
var responseToken = await CallManager.GetToken(_googleDrive);
string _bearerToken = responseToken.Substring(17, 219);
var request = new HttpRequestMessage()
{
Method = HttpMethod.Post,
RequestUri = new Uri(postUri)
};
var path = _path + _fileName;
if (System.IO.File.Exists(path))
{
bool r = true;
}
using (var filestream = System.IO.File.OpenRead(path))
{
var length = filestream.Length.ToString();
var streamContent = new StreamContent(filestream);
streamContent.Headers.Add("Content-Type", "application/octet-stream");
streamContent.Headers.Add("Content-Length", length);
request.Content = streamContent;
var response = new HttpClient().SendAsync(request).Result;
}
return(" ");
}
catch (Exception err)
{
throw err;
}
}
//private static Security security = new Security("servicesceltainfra-6f1e21301fbe.p12");
private static Google.Apis.Drive.v3.DriveService InitGDriveService(ModelGoogleDrive _googleDrive)
{
try
{
Security security = new Security(_googleDrive.CredentialFileName);
var credential = security.AuthenticateServiceAccount(_googleDrive.GoogleDriveAccountMail);
Google.Apis.Drive.v3.DriveService service = new Google.Apis.Drive.v3.DriveService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = "ServicesCeltaInfra"
});
return(service);
}
catch (Exception err)
{
HelperLogs.WriteLog(err.Message + "\br" + err.StackTrace);
throw err;
}
}
public static async Task <string> Upis(string _fileName, string _path, ModelGoogleDrive _googleDrive, string _folderId)
{
try
{
var responseToken = await CallManager.GetToken(_googleDrive);
string _bearerToken = responseToken.Substring(17, 219);
var client = new RestClient("https://www.googleapis.com/upload/drive/v3/files?uploadType=media");
client.Timeout = -1;
var request = new RestRequest(Method.POST);
request.AddParameter("Authorization", "Bearer " + _bearerToken);
request.AddHeader("Content-Type", "multipart/form-data");
request.AddHeader("Content-Length", "436490240");
request.AddFile("CeltaBSEmporioSaborBackupFull.bak", @"C:\Temp\backup\CeltaBSEmporioSaborBackupFull.bak");
IRestResponse response = client.Execute(request);
return(response.Content);
}
catch (Exception err)
{
return(err.Message);
}
}
public async Task <IActionResult> GetFilesFolder()
{
try
{
ModelGoogleDrive googleDrive = new ModelGoogleDrive();
googleDrive = Helpers.HelperGoogleDrive.LoadSetting(_configuration);
//var resultToken = await ServicesCeltaWare.Security.GoogleToken.GetWithRSA256(googleDrive.CredentialFileName);
var response = await CallManager.GetToken(googleDrive);
string onlyToken = response.Substring(17, 219);
var list = await CallManager.ListFilesUri(onlyToken);
return(Ok(list));
}
catch (Exception err)
{
return(BadRequest(err.Message));
}
}
public static async Task <Google.Apis.Drive.v3.Data.File> FindInGoogleDrive(ModelGoogleDrive _googleDrive, string _fileName)
{
try
{
List <string> lista = new List <string>();
Google.Apis.Drive.v3.Data.File gDriveFile = new Google.Apis.Drive.v3.Data.File();
using (var servico = InitGDriveService(_googleDrive))
{
servico.HttpClient.Timeout = TimeSpan.FromHours(4);
var request = servico.Files.List();
request.Fields = "files(id, name, createdTime, modifiedTime, size)";
request.Q = $"'{_googleDrive.FolderId}' in parents";
var resultado = await request.ExecuteAsync();
var arquivos = resultado.Files;
if (arquivos != null && arquivos.Any())
{
foreach (var arquivo in arquivos)
{
if (arquivo.Name.Equals(_fileName))
{
return(arquivo);
}
}
}
//servico.Dispose();
return(gDriveFile);
}
}
catch (Exception err)
{
throw err;
}
}
public static async Task <FileList> GetAllFoldersService(ModelGoogleDrive _googleDrive)
{
try
{
List <string> lista = new List <string>();
using (var servico = InitGDriveService(_googleDrive))
{
var request = servico.Files.List();
request.Fields = "files(id, name)";
var resultado = await request.ExecuteAsync();
// var arquivos = resultado.Files;
servico.Dispose();
return(resultado);
}
}
catch (Exception err)
{
throw err;
}
}
public async Task <string> InitRequestToken(ModelGoogleDrive _googleDrive)
{
try
{
string postUri = "https://oauth2.googleapis.com/device/code";
var request = new HttpRequestMessage()
{
Method = HttpMethod.Post,
RequestUri = new Uri(postUri)
};
request.Properties.Add("client_id", _googleDrive.GoogleAccountId);
request.Properties.Add("scopes", "email");
var streamResult = await client.SendAsync(request);
return(await streamResult.Content.ReadAsStringAsync());
}
catch (Exception err)
{
return(err.Message);
}
}
public static async Task <string> Up(string _fileName, string _path, ModelGoogleDrive _googleDrive, string _folderId)
{
try
{
string postUri = "https://www.googleapis.com/drive/v3/files?uploadType=resumable";
var responseToken = await CallManager.GetToken(_googleDrive);
string _bearerToken = responseToken.Substring(17, 219);
client.DefaultRequestHeaders.Add("Authorization", "Bearer " + _bearerToken);
using (HttpRequestMessage requestMessage = new HttpRequestMessage()
{
Method = HttpMethod.Post,
RequestUri = new Uri(postUri)
})
{
using (var stream = new System.IO.FileStream(_path + _fileName, System.IO.FileMode.Open, System.IO.FileAccess.Read))
{
var length = stream.Length.ToString();
StreamContent sc = new StreamContent(stream);
sc.Headers.Add("Content-Type", "application/json; charset=UTF-8");
sc.Headers.Add("Content-Length", length);
requestMessage.Content = sc;
var response = client.PostAsync(postUri, requestMessage.Content).Result;
return(response.Content.ToString());
}
}
//var request = new HttpRequestMessage()
//{
// Method = HttpMethod.Post,
// RequestUri = new Uri(postUri)
//};
//using (var stream = new System.IO.FileStream(_path + _fileName, System.IO.FileMode.Open, System.IO.FileAccess.Read))
//{
// var length = stream.Length.ToString();
// StreamContent sc = new StreamContent(stream);
// sc.Headers.Add("Content-Type", "application/octet-stream");
// sc.Headers.Add("Content-Length", length);
// request.Content = sc;
// var response = new HttpClient().SendAsync(request).Result;
// //using (var formData = new MultipartFormDataContent())
// //{
// // formData.Add(sc);
// // var response = client.PostAsync(postUri, formData).Result;
// // return response.StatusCode.ToString();
// //}
// return await response.Content.ReadAsStringAsync();
//}
}
catch (Exception err)
{
HelperLogs.WriteLog(err.Message + "\br" + err.StackTrace);
return("ERRO: " + err.Message);
}
}
public async Task <IActionResult> Upload(ModelBackupSchedule _databaseSchedule)
{
try
{
ModelGoogleDrive googleDrive = new ModelGoogleDrive();
googleDrive = Helpers.HelperGoogleDrive.LoadSetting(_configuration);
string path = _databaseSchedule.Databases.Directory + "/" + _databaseSchedule.Directory + "/";
string backupFileName = null;
if (_databaseSchedule.Type == ServicesCeltaWare.Model.Enum.BackuypType.MysqlFull)
{
backupFileName = $"{_databaseSchedule.Databases.ConteinerName}Backup.sql";
}
else
{
backupFileName = Helpers.DatabaseServiceHelper.ReturnBackupName(_databaseSchedule);
}
if (_databaseSchedule.GoogleDriveFolderId == null)
{
return(BadRequest($"{_databaseSchedule.Databases.DatabaseName} GoogleDriveFolderId nulo!"));
}
var resp = await Helpers.HelperGoogleDrive.UploadFromLinux(googleDrive.CredentialFileName, backupFileName, path, _databaseSchedule.GoogleDriveFolderId);
if (resp.Contains("The access token has expired and could not be refreshed"))
{
HelperLogs.WriteLog("GoogleDriveServiceController. ", resp);
var respUpdate = await Helpers.HelperGoogleDrive.UpdateCredential(googleDrive.CredentialFileName);
if (respUpdate.ToUpperInvariant().Contains("OK"))
{
var resp2 = await Helpers.HelperGoogleDrive.UploadFromLinux(googleDrive.CredentialFileName, backupFileName, path, _databaseSchedule.GoogleDriveFolderId);
}
else
{
return(BadRequest("Não foi possível atualizar arquivo de credencial. \n" + respUpdate));
}
}
if (resp.Contains("Failed"))
{
HelperLogs.WriteLog("GoogleDriveServiceController", resp);
await Task.Delay(2000);
var resp2 = await Helpers.HelperGoogleDrive.UploadFromLinux(googleDrive.CredentialFileName, backupFileName, path, _databaseSchedule.GoogleDriveFolderId);
if (resp2.Contains("ok"))
{
resp = resp2;
}
else
{
HelperLogs.WriteLog("GoogleDriveServiceController", resp2);
return(BadRequest("Não foi possível atualizar o backup pela segunda vez!. \n" + resp2));
}
}
if (resp.Contains("ERRO: Arquivo não existe") || resp.Contains("Error:\"invalid_grant\"") ||
resp.Contains("The operation was canceled"))
{
HelperLogs.WriteLog("GoogleDriveServiceController", resp);
return(Forbid());
}
return(Ok(resp));
}
catch (Exception err)
{
if (err.InnerException != null)
{
HelperLogs.WriteLog("GoogleDriveServiceController", err.Message + "\n" + err.InnerException.Message);
return(BadRequest(err.Message + "\n" + err.InnerException.Message));
}
HelperLogs.WriteLog("GoogleDriveServiceController", err.Message);
return(BadRequest(err.Message));
}
}
public static async Task <string> Upload(string _fileName, string _path, ModelGoogleDrive _googleDrive, string _folderId)
{
try
{
Google.Apis.Drive.v3.Data.File response = new Google.Apis.Drive.v3.Data.File();
using (var service = CallManager.InitGDriveService(_googleDrive))
{
service.HttpClient.Timeout = TimeSpan.FromHours(4);
var fileToUpload = new Google.Apis.Drive.v3.Data.File()
{
Name = _fileName,
MimeType = MimeTypesMap.GetMimeType(System.IO.Path.GetExtension(_path)),
Parents = new List <string>
{
_folderId
}
};
// *** Aqui validar se é para Atualizar ou criar !!! ***
// 1 - Caso existe verificar se o mesmo id encontra no GDrive
var isNew = await FindInGoogleDrive(_googleDrive, _fileName);
if (String.IsNullOrEmpty(isNew.DriveId))
{
using (var stream = new System.IO.FileStream(_path + _fileName, System.IO.FileMode.Open, System.IO.FileAccess.Read))
{
var request = service.Files.Create(fileToUpload, stream, fileToUpload.MimeType);
var valid = await request.UploadAsync();
if (valid.Status != Google.Apis.Upload.UploadStatus.Completed)
{
HelperLogs.WriteLog(DateTime.Now + "Resposta de Upload ainda nao completa.");
for (int i = 0; i < 3; i++)
{
await Task.Delay(3000);
if (valid.Status != Google.Apis.Upload.UploadStatus.Completed)
{
i = 3;
}
}
}
response = request.ResponseBody;
// var _file = new Google.Apis.Drive.v3.Data.File();
//_file.Name = System.IO.Path.GetFileName(fullPath);
// _file.Id = request.ResponseBody.Id;
Google.Apis.Drive.v3.Data.File file = request.ResponseBody;
Google.Apis.Drive.v3.Data.Permission newPermission = new Google.Apis.Drive.v3.Data.Permission();
newPermission.EmailAddress = "*****@*****.**";
newPermission.Type = "user";
newPermission.Role = "writer";
Google.Apis.Drive.v3.PermissionsResource.CreateRequest insertRequest = service.Permissions.Create(newPermission, file.Id);
insertRequest.Execute();
}
}
else
{
using (var stream = new System.IO.FileStream(_path + _fileName, System.IO.FileMode.Open, System.IO.FileAccess.Read))
{
var request = service.Files.Update(fileToUpload, isNew.Id, stream, fileToUpload.MimeType);
await request.UploadAsync();
response = request.ResponseBody;
var _file = new Google.Apis.Drive.v3.Data.File();
//_file.Name = System.IO.Path.GetFileName(fullPath);
_file.Id = request.ResponseBody.Id;
//Google.Apis.Drive.v3.Data.File file = request.ResponseBody;
Google.Apis.Drive.v3.Data.Permission newPermission = new Google.Apis.Drive.v3.Data.Permission();
newPermission.EmailAddress = "*****@*****.**";
newPermission.Type = "user";
newPermission.Role = "writer";
Google.Apis.Drive.v3.PermissionsResource.CreateRequest insertRequest = service.Permissions.Create(newPermission, _file.Id);
insertRequest.Execute();
}
}
service.Dispose();
};
if (response == null)
{
return(String.Empty);
}
return(response.Id);
}
catch (TaskCanceledException ex)
{
if (ex.CancellationToken.IsCancellationRequested)
{
return("ERRO: CancellationToken is True.");
}
return("ERRO CancellationToken is False");
}
catch (Exception err)
{
HelperLogs.WriteLog(err.Message + "\br" + err.StackTrace);
return("ERRO: " + err.Message);
}
}
static void Main(string[] args)
{
Console.WriteLine("Pressione Enter para solicitar autenticação");
Console.ReadLine();
ModelGoogleDrive.GetFolders("GDrive");
}
public CallManager(ModelGoogleDrive _googleDrive)
{
googleDrive = _googleDrive;
client.Timeout = TimeSpan.FromHours(4);
}
