/// <summary>Snippet for ListCollectionIds</summary>
public async Task ListCollectionIdsAsync()
{
// Snippet: ListCollectionIdsAsync(string, string, int?, CallSettings)
// Create client
FirestoreClient firestoreClient = await FirestoreClient.CreateAsync();
// Initialize request argument(s)
string parent = "";
// Make the request
PagedAsyncEnumerable <ListCollectionIdsResponse, string> response = firestoreClient.ListCollectionIdsAsync(parent);
// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((string item) =>
{
// Do something with each item
Console.WriteLine(item);
});
// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListCollectionIdsResponse page) =>
{
// Do something with each page of items
Console.WriteLine("A page of results:");
foreach (string item in page)
{
// Do something with each item
Console.WriteLine(item);
}
});
// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page <string> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (string item in singlePage)
{
// Do something with each item
Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;
// End snippet
}
public FirebaseDocumentListener(FirestoreDb db)
{
// Create client
FirestoreDb = db;
FirestoreClient = db.Client; //FirestoreClient.Create();
ProjectId = db.ProjectId;
DatabaseId = db.DatabaseId;
//Setup no expiration for the listen
ListenSettings = CallSettings.FromCallTiming(CallTiming.FromExpiration(Expiration.None));
//Start our handler for writing requests to GCP
RequestHanderTask = StartRequestHandlerTask();
//Initialize a cancelation source so we can cancel tasks we create
CancellationTokenSource = new CancellationTokenSource();
CancellationToken = CancellationTokenSource.Token;
}
/// <summary>Snippet for DeleteDocumentAsync</summary>
public async Task DeleteDocumentRequestObjectAsync()
{
// Snippet: DeleteDocumentAsync(DeleteDocumentRequest, CallSettings)
// Additional: DeleteDocumentAsync(DeleteDocumentRequest, CancellationToken)
// Create client
FirestoreClient firestoreClient = await FirestoreClient.CreateAsync();
// Initialize request argument(s)
DeleteDocumentRequest request = new DeleteDocumentRequest
{
Name = "",
CurrentDocument = new Precondition(),
};
// Make the request
await firestoreClient.DeleteDocumentAsync(request);
// End snippet
}
private FirestoreDb(string projectId, string databaseId, FirestoreClient client, Action <string> warningLogger, SerializationContext serializationContext)
{
ProjectId = GaxPreconditions.CheckNotNull(projectId, nameof(projectId));
DatabaseId = GaxPreconditions.CheckNotNull(databaseId, nameof(databaseId));
Client = GaxPreconditions.CheckNotNull(client, nameof(client));
// TODO: Investigate using DatabaseName and DocumentPathName.
RootPath = $"projects/{ProjectId}/databases/{DatabaseId}";
DocumentsPath = $"{RootPath}/documents";
WarningLogger = warningLogger;
// TODO: Validate these settings, and potentially make them configurable
_batchGetCallSettings = CallSettings.FromCallTiming(CallTiming.FromRetry(new RetrySettings(
retryBackoff: new BackoffSettings(TimeSpan.FromMilliseconds(500), TimeSpan.FromSeconds(5), 2.0),
timeoutBackoff: new BackoffSettings(TimeSpan.FromMinutes(1), TimeSpan.FromMinutes(3), 2.0),
Expiration.FromTimeout(TimeSpan.FromMinutes(10)),
RetrySettings.FilterForStatusCodes(StatusCode.Unavailable))));
SerializationContext = GaxPreconditions.CheckNotNull(serializationContext, nameof(serializationContext));
}
public static FirestoreDb CreateFirestoreDb(IServiceProvider provider)
{
var authOptions = provider.GetRequiredService <IOptions <OAuthServiceAccountKey> >();
var path = Path.GetTempFileName();
var json = JsonConvert.SerializeObject(authOptions.Value);
using var writer = File.CreateText(path);
writer.Write(json);
writer.Flush();
writer.Close();
Environment.SetEnvironmentVariable("GOOGLE_APPLICATION_CREDENTIALS", path);
var client = FirestoreClient.Create();
return(FirestoreDb.Create(authOptions.Value.project_id, client: client));
}
/// <summary>Snippet for RollbackAsync</summary>
public async Task RollbackRequestObjectAsync()
{
// Snippet: RollbackAsync(RollbackRequest, CallSettings)
// Additional: RollbackAsync(RollbackRequest, CancellationToken)
// Create client
FirestoreClient firestoreClient = await FirestoreClient.CreateAsync();
// Initialize request argument(s)
RollbackRequest request = new RollbackRequest
{
Database = "",
Transaction = ByteString.Empty,
};
// Make the request
await firestoreClient.RollbackAsync(request);
// End snippet
}
/// <summary>Snippet for UpdateDocumentAsync</summary>
public async Task UpdateDocumentAsync_RequestObject()
{
// Snippet: UpdateDocumentAsync(UpdateDocumentRequest,CallSettings)
// Additional: UpdateDocumentAsync(UpdateDocumentRequest,CancellationToken)
// Create client
FirestoreClient firestoreClient = await FirestoreClient.CreateAsync();
// Initialize request argument(s)
UpdateDocumentRequest request = new UpdateDocumentRequest
{
Document = new Document(),
UpdateMask = new DocumentMask(),
};
// Make the request
Document response = await firestoreClient.UpdateDocumentAsync(request);
// End snippet
}
/// <summary>Snippet for BeginTransactionAsync</summary>
public async Task BeginTransactionRequestObjectAsync()
{
// Snippet: BeginTransactionAsync(BeginTransactionRequest, CallSettings)
// Additional: BeginTransactionAsync(BeginTransactionRequest, CancellationToken)
// Create client
FirestoreClient firestoreClient = await FirestoreClient.CreateAsync();
// Initialize request argument(s)
BeginTransactionRequest request = new BeginTransactionRequest
{
Database = "",
Options = new TransactionOptions(),
};
// Make the request
BeginTransactionResponse response = await firestoreClient.BeginTransactionAsync(request);
// End snippet
}
/// <summary>Snippet for CommitAsync</summary>
public async Task CommitAsync_RequestObject()
{
// Snippet: CommitAsync(CommitRequest,CallSettings)
// Additional: CommitAsync(CommitRequest,CancellationToken)
// Create client
FirestoreClient firestoreClient = await FirestoreClient.CreateAsync();
// Initialize request argument(s)
CommitRequest request = new CommitRequest
{
Database = new DatabaseRootName("[PROJECT]", "[DATABASE]").ToString(),
Writes = { },
};
// Make the request
CommitResponse response = await firestoreClient.CommitAsync(request);
// End snippet
}
/// <summary>Snippet for RollbackAsync</summary>
public async Task RollbackAsync_RequestObject()
{
// Snippet: RollbackAsync(RollbackRequest,CallSettings)
// Additional: RollbackAsync(RollbackRequest,CancellationToken)
// Create client
FirestoreClient firestoreClient = await FirestoreClient.CreateAsync();
// Initialize request argument(s)
RollbackRequest request = new RollbackRequest
{
Database = new DatabaseRootName("[PROJECT]", "[DATABASE]").ToString(),
Transaction = Google.Protobuf.ByteString.CopyFromUtf8(""),
};
// Make the request
await firestoreClient.RollbackAsync(request);
// End snippet
}
/// <summary>Snippet for CreateDocument</summary>
public void CreateDocumentRequestObject()
{
// Snippet: CreateDocument(CreateDocumentRequest, CallSettings)
// Create client
FirestoreClient firestoreClient = FirestoreClient.Create();
// Initialize request argument(s)
CreateDocumentRequest request = new CreateDocumentRequest
{
Parent = "",
CollectionId = "",
DocumentId = "",
Document = new Document(),
Mask = new DocumentMask(),
};
// Make the request
Document response = firestoreClient.CreateDocument(request);
// End snippet
}
/// <summary>Snippet for CreateDocumentAsync</summary>
public async Task CreateDocumentAsync_RequestObject()
{
// Snippet: CreateDocumentAsync(CreateDocumentRequest,CallSettings)
// Create client
FirestoreClient firestoreClient = await FirestoreClient.CreateAsync();
// Initialize request argument(s)
CreateDocumentRequest request = new CreateDocumentRequest
{
Parent = new AnyPathName("[PROJECT]", "[DATABASE]", "[DOCUMENT]", "[ANY_PATH]").ToString(),
CollectionId = "",
DocumentId = "",
Document = new Document(),
};
// Make the request
Document response = await firestoreClient.CreateDocumentAsync(request);
// End snippet
}
/// <summary>Snippet for GetDocumentAsync</summary>
public async Task GetDocumentRequestObjectAsync()
{
// Snippet: GetDocumentAsync(GetDocumentRequest, CallSettings)
// Additional: GetDocumentAsync(GetDocumentRequest, CancellationToken)
// Create client
FirestoreClient firestoreClient = await FirestoreClient.CreateAsync();
// Initialize request argument(s)
GetDocumentRequest request = new GetDocumentRequest
{
Name = "",
Mask = new DocumentMask(),
Transaction = ByteString.Empty,
};
// Make the request
Document response = await firestoreClient.GetDocumentAsync(request);
// End snippet
}
/// <summary>Snippet for CommitAsync</summary>
public async Task CommitRequestObjectAsync()
{
// Snippet: CommitAsync(CommitRequest, CallSettings)
// Additional: CommitAsync(CommitRequest, CancellationToken)
// Create client
FirestoreClient firestoreClient = await FirestoreClient.CreateAsync();
// Initialize request argument(s)
CommitRequest request = new CommitRequest
{
Database = "",
Writes = { new Write(), },
Transaction = ByteString.Empty,
};
// Make the request
CommitResponse response = await firestoreClient.CommitAsync(request);
// End snippet
}
/// <summary>
/// Fetches document data from firestore db
/// </summary>
/// <returns></returns>
public async Task <ActionResult> Index()
{
string project = "ainfirestoreproject";
var mappedPath = Server.MapPath("/Certificate/ainfirestoreproject-139fe45328fd.json");
var credential = GoogleCredential.FromFile(mappedPath);
var channel = new Grpc.Core.Channel(
FirestoreClient.DefaultEndpoint.ToString(),
credential.ToChannelCredentials());
var client = FirestoreClient.Create(channel);
var db = FirestoreDb.Create(project, client: client);
System.Diagnostics.Debug.WriteLine("Created Cloud Firestore client with project ID: {0}", project);
CollectionReference usersRef = db.Collection("tests");
var snapshot = await usersRef.GetSnapshotAsync();
return(View(snapshot));
}
/// <summary>Snippet for BatchWriteAsync</summary>
public async Task BatchWriteRequestObjectAsync()
{
// Snippet: BatchWriteAsync(BatchWriteRequest, CallSettings)
// Additional: BatchWriteAsync(BatchWriteRequest, CancellationToken)
// Create client
FirestoreClient firestoreClient = await FirestoreClient.CreateAsync();
// Initialize request argument(s)
BatchWriteRequest request = new BatchWriteRequest
{
Database = "",
Writes = { new Write(), },
Labels = { { "", "" }, },
};
// Make the request
BatchWriteResponse response = await firestoreClient.BatchWriteAsync(request);
// End snippet
}
public FirestoreContext()
{
var path = Path.GetFullPath(Path.Combine(Environment.CurrentDirectory, @"Resources/Keys\gcloud_service_account.json"));
/*
* FirebaseApp.Create(new AppOptions()
* {
* Credential = GoogleCredential.FromFile(path),
* });*/
var credential = GoogleCredential.FromFile(path);
var projectID = "tinglysning-b87b2";
var channelCredentials = credential.ToChannelCredentials();
var channel = new Channel(FirestoreClient.DefaultEndpoint.ToString(), channelCredentials);
var firestoreClient = FirestoreClient.Create(channel);
Database = FirestoreDb.Create(projectID, client: firestoreClient);
}
/// <summary>Snippet for ListCollectionIds</summary>
public void ListCollectionIds()
{
// Snippet: ListCollectionIds(string,string,int?,CallSettings)
// Create client
FirestoreClient firestoreClient = FirestoreClient.Create();
// Initialize request argument(s)
string formattedParent = new AnyPathName("[PROJECT]", "[DATABASE]", "[DOCUMENT]", "[ANY_PATH]").ToString();
// Make the request
PagedEnumerable <ListCollectionIdsResponse, string> response =
firestoreClient.ListCollectionIds(formattedParent);
// Iterate over all response items, lazily performing RPCs as required
foreach (string item in response)
{
// Do something with each item
Console.WriteLine(item);
}
// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListCollectionIdsResponse page in response.AsRawResponses())
{
// Do something with each page of items
Console.WriteLine("A page of results:");
foreach (string item in page)
{
Console.WriteLine(item);
}
}
// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page <string> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (string item in singlePage)
{
Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;
// End snippet
}
static void Main(string[] args)
{
string project = "YOUR_PROJECT_ID";
GoogleCredential cred = GoogleCredential.FromFile(@"C:\[YOUR_PATH]\[YOUR_FILE].json");
Channel channel = new Channel(FirestoreClient.DefaultEndpoint.Host,
FirestoreClient.DefaultEndpoint.Port,
cred.ToChannelCredentials());
FirestoreClient client = FirestoreClient.Create(channel);
FirestoreDb db = FirestoreDb.Create(project, client);
Console.WriteLine("Created Cloud Firestore client with project ID: {0}", project);
//GoogleApiImplement.callAddDataHelper(db);
FireStoreApiImplementation.callRetrieveDataHelper(db);
Console.ReadLine();
}
/// <summary>
/// Adds an Firebase implementation of identity stores.
/// </summary>
/// <param name="builder">The <see cref="IdentityBuilder"/> instance this method extends.</param>
/// <param name="configure">Action to configure AuthTokenOptions</param>
/// <returns>The <see cref="IdentityBuilder"/> instance this method extends.</returns>
public static IdentityBuilder AddFirestoreStores(this IdentityBuilder builder, Action <OAuthServiceAccountKey> configure)
{
var services = builder.Services;
services.Configure(configure)
.AddScoped(provider =>
{
var authOptions = provider.GetRequiredService <IOptions <OAuthServiceAccountKey> >();
var json = JsonConvert.SerializeObject(authOptions.Value);
var credentials = GoogleCredential.FromJson(json)
.CreateScoped("https://www.googleapis.com/auth/datastore");
var channel = new Grpc.Core.Channel(
FirestoreClient.DefaultEndpoint.ToString(),
credentials.ToChannelCredentials());
var client = FirestoreClient.Create(channel);
return(FirestoreDb.Create(authOptions.Value.project_id, client: client));
});
AddStores(services, builder.UserType, builder.RoleType);
return(builder);
}
/// <summary>Snippet for CreateDocumentAsync</summary>
public async Task CreateDocumentRequestObjectAsync()
{
// Snippet: CreateDocumentAsync(CreateDocumentRequest, CallSettings)
// Additional: CreateDocumentAsync(CreateDocumentRequest, CancellationToken)
// Create client
FirestoreClient firestoreClient = await FirestoreClient.CreateAsync();
// Initialize request argument(s)
CreateDocumentRequest request = new CreateDocumentRequest
{
Parent = "",
CollectionId = "",
DocumentId = "",
Document = new Document(),
Mask = new DocumentMask(),
};
// Make the request
Document response = await firestoreClient.CreateDocumentAsync(request);
// End snippet
}
public async Task <FirestoreDb> DataBase()
{
FirebaseAuthService authService = new FirebaseAuthService();
var auth = authService.LoadAuth();
var firebaseToken = auth.FirebaseToken;
if (auth.IsExpired())
{
firebaseToken = await authService.GetFreshTokenAsync();
}
var credential = GoogleCredential.FromAccessToken(firebaseToken);
Channel channel = new Channel(FirestoreClient.DefaultEndpoint.Host, FirestoreClient.DefaultEndpoint.Port, credential.ToChannelCredentials());
FirestoreClient client = FirestoreClient.Create(channel);
return(FirestoreDb.Create(project, client));
}
public async Task <Google.Cloud.Firestore.WriteResult> AddFieldsbyDictionaryAsync(IDictionary <string, object> datas, string collectionName, string documentName)
{
FirestoreClient client = FirestoreClient.Create(channel);
FirestoreDb db = await FirestoreDb.CreateAsync(configuration["GCPSetting:PROJECTNAME"], client);
Google.Cloud.Firestore.WriteResult result;
var document = db.Collection(collectionName).Document(documentName);
var snapshot = await document.GetSnapshotAsync();
if (snapshot.Exists)
{
result = await document.UpdateAsync(datas);
}
else
{
result = await document.CreateAsync(datas);
}
return(result);
}
/// <summary>
///
/// </summary>
/// <typeparam name="T">What kind of object are you sending me</typeparam>
/// <param name="collection">Top folder</param>
/// <param name="obj">The data</param>
/// <param name="id">The collection in the document</param>
/// <returns></returns>
public async Task AddData <T>(string collection, T obj, string id)
{
try
{
var serviceAcct = GoogleCredential.FromJson(_config.GetValue <string>("jsonCreds"));
Channel channel = new Channel(
FirestoreClient.DefaultEndpoint.Host, FirestoreClient.DefaultEndpoint.Port,
serviceAcct.ToChannelCredentials());
FirestoreClient client = FirestoreClient.Create(channel);
FirestoreDb db = FirestoreDb.Create(_config.GetValue <string>("projectId"), client);
CollectionReference docRef = db.Collection(collection);
await docRef.AddAsync(obj);
}
catch (Exception ex)
{
throw ex;
}
}
public static async Task Authenticate()
{
FirebaseAuthService authService = new FirebaseAuthService();
//var firebaseAuthLink = await authService.LoginUser("*****@*****.**", "password");
var firebaseToken = await authService.GetFreshToken();
var project = "firestoredemo-262aa";
var credential = GoogleCredential.FromAccessToken(firebaseToken);
Channel channel = new Channel(
FirestoreClient.DefaultEndpoint.Host, FirestoreClient.DefaultEndpoint.Port,
credential.ToChannelCredentials());
FirestoreClient client = FirestoreClient.Create(channel);
FirestoreDb db = FirestoreDb.Create(project, client);
Tool tool = new Tool
{
Name = "2.0MM BM LONG FINISH",
Number = "4"
};
ExecutionData executionData = new ExecutionData
{
SelectedProgram = "Selected.program.running",
ActiveProgram = "Active.program.running"
};
Machine machine = new Machine
{
Name = "Mikron HSM 200U LP",
Ip = "192.168.1.150",
MachineName = "Mikron 1",
Tool = tool,
ExecutationData = executionData
};
SaveMachine(db, machine);
}
private FirestoreDb(string projectId, string databaseId, FirestoreClient client, Action <string> warningLogger, SerializationContext serializationContext)
{
ProjectId = GaxPreconditions.CheckNotNull(projectId, nameof(projectId));
DatabaseId = GaxPreconditions.CheckNotNull(databaseId, nameof(databaseId));
Client = GaxPreconditions.CheckNotNull(client, nameof(client));
// TODO: Investigate using DatabaseName and DocumentPathName.
RootPath = $"projects/{ProjectId}/databases/{DatabaseId}";
DocumentsPath = $"{RootPath}/documents";
WarningLogger = warningLogger;
// TODO: Validate these settings, and potentially make them configurable
var batchGetRetry = RetrySettings.FromExponentialBackoff(
maxAttempts: int.MaxValue,
initialBackoff: TimeSpan.FromMilliseconds(500),
maxBackoff: TimeSpan.FromSeconds(5),
backoffMultiplier: 2.0,
retryFilter: RetrySettings.FilterForStatusCodes(StatusCode.Unavailable));
_batchGetCallSettings = CallSettings.FromRetry(batchGetRetry).WithTimeout(TimeSpan.FromMinutes(10));
SerializationContext = GaxPreconditions.CheckNotNull(serializationContext, nameof(serializationContext));
}
private FirestoreDb CreateDb()
{
var builder = new ConfigurationBuilder();
var configuration = builder
.AddEnvironmentVariables()
.AddJsonFile(Path.Combine(Directory.GetCurrentDirectory(), "../../../../identityfirestore.json"))
.Build();
var services = new ServiceCollection();
services.Configure((Action <OAuthServiceAccountKey>)(options =>
{
configuration.GetSection("FirestoreAuthTokenOptions").Bind(options);
}))
.AddScoped(provider =>
{
CreateAuthFile(provider, out IOptions <OAuthServiceAccountKey> authOptions);
var client = FirestoreClient.Create();
return(FirestoreDb.Create(authOptions.Value.project_id, client: client));
});
return(services.BuildServiceProvider().GetRequiredService <FirestoreDb>());
}
private FirestoreDb(string projectId, string databaseId, FirestoreClient client, Action <string> warningLogger, SerializationContext serializationContext)
{
ProjectId = GaxPreconditions.CheckNotNull(projectId, nameof(projectId));
DatabaseId = GaxPreconditions.CheckNotNull(databaseId, nameof(databaseId));
Client = GaxPreconditions.CheckNotNull(client, nameof(client));
// TODO: Investigate using DatabaseName and DocumentPathName.
RootPath = $"projects/{ProjectId}/databases/{DatabaseId}";
DocumentsPath = $"{RootPath}/documents";
WarningLogger = warningLogger;
// TODO: Potentially make these configurable.
// The retry settings are taken from firestore_grpc_service_config.json.
var batchGetRetry = RetrySettings.FromExponentialBackoff(
maxAttempts: 5,
initialBackoff: TimeSpan.FromMilliseconds(100),
maxBackoff: TimeSpan.FromSeconds(60),
backoffMultiplier: 1.3,
retryFilter: RetrySettings.FilterForStatusCodes(StatusCode.Unavailable, StatusCode.Internal, StatusCode.DeadlineExceeded));
_batchGetCallSettings = CallSettings.FromRetry(batchGetRetry).WithTimeout(TimeSpan.FromMinutes(10));
SerializationContext = GaxPreconditions.CheckNotNull(serializationContext, nameof(serializationContext));
}
public async Task <bool> LoginAsync(string email, string password)
{
GoogleCredential credential = GoogleCredential
.FromFile("auth.json");
ChannelCredentials channelCredentials = credential.ToChannelCredentials();
Channel channel = new Channel(FirestoreClient.DefaultEndpoint.ToString(), channelCredentials);
FirestoreClient firestoreClient = FirestoreClient.Create(channel);
this.Client = firestoreClient;
return(await Task.FromResult(true));
//try
//{
// UserCredential credential;
// using (var stream = new FileStream("client_secrets.json", FileMode.Open, FileAccess.Read))
// {
// credential = await GoogleWebAuthorizationBroker.AuthorizeAsync(
// GoogleClientSecrets.Load(stream).Secrets,
// new[] { BooksService.Scope.Books },
// "user", CancellationToken.None, new FileDataStore("Books.ListMyLibrary"));
// }
// //this._authResult = await CrossFirebaseAuth.Current
// // .GetInstance(ApiKeys.FirebaseName)
// // .SignInWithEmailAndPasswordAsync(email, password);
//}
//catch (Exception ex)
//{
// throw;
//}
////return this._authResult != null && this._authResult.User != null;
//return await Task.FromResult(false);
}
public async Task <Google.Cloud.Firestore.WriteResult> DeleteFieldData(string collectionName, string documentName, List <string> keys)
{
FirestoreClient client = FirestoreClient.Create(channel);
FirestoreDb db = await FirestoreDb.CreateAsync(configuration["GCPSetting:PROJECTNAME"], client);
var document = db.Collection(collectionName).Document(documentName);
var snapshot = await document.GetSnapshotAsync();
if (snapshot.Exists)
{
Dictionary <string, object> updates = new Dictionary <string, object>();
keys.ForEach(key =>
{
updates.Add(key, FieldValue.Delete);
});
Google.Cloud.Firestore.WriteResult writeResult = await document.UpdateAsync(updates);
return(writeResult);
}
return(null);
}
