public async Task <ResponseModel> AddRecord(RequestModel request, string appKey, string baseId) { var responseModel = new ResponseModel { ID = Utilities.GenerateID(), Title = request.Title, Text = request.Text, ReceivedAt = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ss.fffZ"), }; using AirtableBase airtableBase = new AirtableBase(appKey, baseId); var fields = new Fields(); fields.AddField("id", responseModel.ID); fields.AddField("Summary", responseModel.Title); fields.AddField("Message", responseModel.Text); fields.AddField("receivedAt", responseModel.ReceivedAt); Task <AirtableCreateUpdateReplaceRecordResponse> task = airtableBase.CreateRecord("Messages", fields); AirtableCreateUpdateReplaceRecordResponse response = await task; if (response.Success) { return(responseModel); } else if (response.AirtableApiError is AirtableApiException) { throw new InvalidOperationException(response.AirtableApiError.ErrorMessage); } else { throw new InvalidOperationException("Unknown error"); } }
// public async Task <bool> LoopTasks() { AirtableBase airtableBase = new AirtableBase(appKey, baseID); var tasks = new List <Task <AirtableRetrieveRecordResponse> >(); foreach (string stringID in stringIDs) { if (stringID != null) { Task <AirtableDeleteRecordResponse> task = airtableBase.DeleteRecord(tablename, stringID); response = await task; if (response.Success) { errorMessage = "Success!"; } else { errorMessage = response.AirtableApiError.ErrorMessage; } } else { errorMessage = response.AirtableApiError.DetailedErrorMessage2; } } return(true); }
// STATUS [ July 13, 2019 ] : this works /// <summary> /// Get all the records from a given table /// </summary> /// <remarks> /// Configuration for each table is setup in Startup.cs and airtableConfiguration.json /// See: https://github.com/ngocnicholas/airtable.net /// </remarks> /// <param name="tableName"> /// Equivalent to the TableName in airtableConfiguration.json /// Equivalent to the tab name in actual airtable /// </param> /// <param name="tableAuthenticationString"> /// Equivalent to the AuthenticationString in airtableConfiguration.json /// </param> /// <example> /// var listOfRecords = await _atM.GetAllRecordsFromAirtableAsync(_spRankingsConfiguration.TableName, _spRankingsConfiguration.AuthenticationString); /// </example> public async Task <List <AirtableRecord> > GetAllRecordsFromAirtableAsync(string tableName, string tableAuthenticationString) { string offset = null; string errorMessage = null; List <AirtableRecord> records = new List <AirtableRecord>(); using (AirtableBase airtableBase = new AirtableBase(_airtableConfig.ApiKey, tableAuthenticationString)) { Task <AirtableListRecordsResponse> task = airtableBase.ListRecords( tableName: tableName ); AirtableListRecordsResponse airResponse = await task.ConfigureAwait(false); if (airResponse.Success) { records.AddRange(airResponse.Records.ToList()); offset = airResponse.Offset; } else { errorMessage = airResponse.AirtableApiError is AirtableApiException ? airResponse.AirtableApiError.ErrorMessage : "Unknown error"; } } if (!string.IsNullOrEmpty(errorMessage)) { C.WriteLine("ERROR"); } return(records); }
public ThingsData(IConfiguration config) { var baseId = config.GetValue <string>("AirtableBaseId"); var apiKey = config.GetValue <string>("AirtableApiKey"); Airtable = new AirtableBase(apiKey, baseId); }
public async Task <AirtableRetrieveRecordResponse> GetRecordMethodAsync(AirtableBase airtableBase, String stringIDparam) { Task <AirtableRetrieveRecordResponse> task = airtableBase.RetrieveRecord(tablename, stringIDparam); response = await task; return(response); }
public async Task <(bool, string, List <AirtableRecord>)> FetchRecordsFilterByFormula(string table, string formula, List <string> fields) { string errorMessage = null; bool success = false; var records = new List <AirtableRecord>(); string offset = null; using (AirtableBase airtableBase = new AirtableBase(ApiKey, BaseId)) { Task <AirtableListRecordsResponse> task = airtableBase.ListRecords( table, offset, fields, formula); AirtableListRecordsResponse response = await task; if (response.Success) { records.AddRange(response.Records.OrderBy(r => r.Fields["Date"]).ToList()); offset = response.Offset; } else if (response.AirtableApiError is AirtableApiException) { errorMessage = response.AirtableApiError.GetBaseException().Message; } else { errorMessage = "Unknown error"; } success = response.Success; } return(success, errorMessage, records); }
private async void Render(object state) { using var airtableBase = new AirtableBase(_configuration["Airtable:Key"], _configuration["Airtable:Base"]); var response = await airtableBase.ListRecords( "Redirections", view : "Main", maxRecords : 1); if (!response.Success) { return; } var records = response.Records .ToDictionary(x => x.Fields["Base Address"].ToString(), x => new DomainMappingValue { Desktop = new DomainVariantValue { Url = x.Fields["Desktop Redirection"].ToString() }, Mobile = new DomainVariantValue { Url = x.Fields["Mobile Redirection"].ToString() } }); foreach (var record in records) { record.Value.Mobile.Html = await FillHtmlCache("http://" + record.Value.Mobile.Url); record.Value.Desktop.Html = await FillHtmlCache("http://" + record.Value.Desktop.Url); _memoryCache.Set(record.Key, record.Value); } }
public Task <Object> Handle(AddInvoiceExceptionRecordToAirtableCommand request, CancellationToken cancellationToken) { const string airtableApiKey = "keyouw8CITeZrgZqx"; const string invoiceExceptionBaseKey = "appq4DBeNHZdRSoa1"; var airTableBase = new AirtableBase(airtableApiKey, invoiceExceptionBaseKey); var airtableFields = new Fields(); if (request.FlaggedJob != null) { airtableFields.FieldsCollection.Add("job_id", request.FlaggedJob.FlaggedJobId.ToString()); airtableFields.FieldsCollection.Add("flagged_material_code", request.FlaggedJob.FlaggedMaterialCode); airtableFields.FieldsCollection.Add("technician_name", request.FlaggedJob.TechnicianName); airtableFields.FieldsCollection.Add("job_completed_date", DateTime.Parse(request.FlaggedJob.JobCompletedDate)); airtableFields.FieldsCollection.Add("job_url", "https://go.servicetitan.com/#/Job/Index/" + request.FlaggedJob.FlaggedJobId.ToString()); airtableFields.FieldsCollection.Add("service_code", request.FlaggedJob.ServiceCode); } if (request.InvoiceError != null) { airtableFields.FieldsCollection.Add("job_id", request.InvoiceError.FlaggedJobId.ToString()); airtableFields.FieldsCollection.Add("flagged_material_code", request.InvoiceError.FlaggedMaterialCode); airtableFields.FieldsCollection.Add("technician_name", request.InvoiceError.TechnicianName); airtableFields.FieldsCollection.Add("job_completed_date", DateTime.Parse(request.InvoiceError.JobCompletedDate)); airtableFields.FieldsCollection.Add("job_url", "https://go.servicetitan.com/#/Job/Index/" + request.InvoiceError.FlaggedJobId.ToString()); airtableFields.FieldsCollection.Add("service_code", request.InvoiceError.ServiceCode); } var result = airTableBase.CreateRecord("exception_list", airtableFields, true).Result; return(Task.FromResult <Object>(result)); }
public async Task <(bool, string)> PostAttachmentToRecord(string magazineCoverUrl, string table, string recordId) { AirtableAttachment attachment = new AirtableAttachment() { Url = magazineCoverUrl }; List <AirtableAttachment> attachmentList = new List <AirtableAttachment> { attachment }; using (AirtableBase airtableBase = new AirtableBase(ApiKey, BaseId)) { var fields = new Fields(); fields.AddField("Cover", attachmentList); var task = airtableBase.UpdateRecord(table, fields, recordId); var response = await task; if (response.Success) { return(true, null); } else if (response.AirtableApiError is AirtableApiException) { return(false, response.AirtableApiError.GetBaseException().Message); } else { return(false, "Unknown error"); } } }
public static async Task ReportScores(Set set, double gain, double loss) { using (AirtableBase airtableBase = new AirtableBase(Globals.BotSettings.AppKey, Globals.BotSettings.BaseId)) { Fields fields = new Fields(); string[] alphaPlayers = set.AlphaTeam.Players.Select(e => e.AirtableId).ToArray(); string[] bravoPlayers = set.BravoTeam.Players.Select(e => e.AirtableId).ToArray(); fields.AddField("Date", DateTime.Now); fields.AddField("Alpha Players", alphaPlayers); fields.AddField("Bravo Players", bravoPlayers); fields.AddField("Alpha Score", set.AlphaTeam.Score); fields.AddField("Bravo Score", set.BravoTeam.Score); fields.AddField("Gain", gain); fields.AddField("Loss", loss); fields.AddField("A SZ", set.AlphaTeam.OrderedMatchResults .Select((e, index) => new { Score = e, set.Stages[index].Mode }) .Where(e => e.Score == 1 && e.Mode == GameMode.SplatZones) .Aggregate(0, (e, f) => e + f.Score)); fields.AddField("B SZ", set.BravoTeam.OrderedMatchResults .Select((e, index) => new { Score = e, set.Stages[index].Mode }) .Where(e => e.Score == 1 && e.Mode == GameMode.SplatZones) .Aggregate(0, (e, f) => e + f.Score)); fields.AddField("A TC", set.AlphaTeam.OrderedMatchResults .Select((e, index) => new { Score = e, set.Stages[index].Mode }) .Where(e => e.Score == 1 && e.Mode == GameMode.TowerControl) .Aggregate(0, (e, f) => e + f.Score)); fields.AddField("B TC", set.BravoTeam.OrderedMatchResults .Select((e, index) => new { Score = e, set.Stages[index].Mode }) .Where(e => e.Score == 1 && e.Mode == GameMode.TowerControl) .Aggregate(0, (e, f) => e + f.Score)); fields.AddField("A RM", set.AlphaTeam.OrderedMatchResults .Select((e, index) => new { Score = e, set.Stages[index].Mode }) .Where(e => e.Score == 1 && e.Mode == GameMode.Rainmaker) .Aggregate(0, (e, f) => e + f.Score)); fields.AddField("B RM", set.BravoTeam.OrderedMatchResults .Select((e, index) => new { Score = e, set.Stages[index].Mode }) .Where(e => e.Score == 1 && e.Mode == GameMode.Rainmaker) .Aggregate(0, (e, f) => e + f.Score)); fields.AddField("A CB", set.AlphaTeam.OrderedMatchResults .Select((e, index) => new { Score = e, set.Stages[index].Mode }) .Where(e => e.Score == 1 && e.Mode == GameMode.ClamBlitz) .Aggregate(0, (e, f) => e + f.Score)); fields.AddField("B CB", set.BravoTeam.OrderedMatchResults .Select((e, index) => new { Score = e, set.Stages[index].Mode }) .Where(e => e.Score == 1 && e.Mode == GameMode.ClamBlitz) .Aggregate(0, (e, f) => e + f.Score)); await airtableBase.CreateRecord("Draft Log", fields, true); } }
// public async Task CreateRecordMethodAsync(AirtableBase airtableBase) { Task <AirtableCreateUpdateReplaceRecordResponse> task = airtableBase.CreateRecord(tablename, fields, conversion); var response = await task; OutRecord = response.Record; if (response.AirtableApiError.ErrorMessage != null) { // Error reporting errorMessageString = response.AirtableApiError.ErrorMessage; } else { // Do something with the retrieved 'record' errorMessageString = "Success!"; OutRecord = response.Record; } if (response.Success == true) { errorMessageString = "Success!"; } }
//=========================== CREATE/POST =========================================== public async Task <AirtableCreateUpdateReplaceRecordResponse> Create(RecordCreateRequest req) { using (AirtableBase airtableBase = new AirtableBase(appKey, baseId)) { var fields = new Fields(); fields.AddField("Title", req.Title); fields.AddField("Priority", req.Priority); fields.AddField("Status", req.Status); fields.AddField("Due Date", req.DueDate); AirtableCreateUpdateReplaceRecordResponse response = await airtableBase.CreateRecord(tableName, fields, true); if (!response.Success) { if (response.AirtableApiError is AirtableApiException) { errorMessage = response.AirtableApiError.ErrorMessage; } else { errorMessage = "Unknown error"; } // Report errorMessage } else { // Do something with your created record. Console.WriteLine("ok"); } return(response); } }
public async Task <AirtableCreateUpdateReplaceRecordResponse> UpdateRecord(RecordUpdateRequest req) { using (AirtableBase airtableBase = new AirtableBase(appKey, baseId)) { var fields = new Fields(); fields.AddField("Title", req.Title); fields.AddField("Priority", req.Priority); fields.AddField("Status", req.Status); fields.AddField("Due Date", req.DueDate); AirtableCreateUpdateReplaceRecordResponse response = await airtableBase.UpdateRecord(tableName, fields, req.Id.ToString()); //var response = await task; if (!response.Success) { string errorMessage = null; if (response.AirtableApiError is AirtableApiException) { errorMessage = response.AirtableApiError.ErrorMessage; } else { errorMessage = "Unknown error"; } // Report errorMessage } else { var record = response.Record; // Do something with your updated record. } return(response); } }
public async Task <string> GetRecord(string table, string recordId) { string errorMessage = null; var records = new List <AirtableRecord>(); AirtableRecord myRecord = new AirtableRecord(); using (AirtableBase airtableBase = new AirtableBase(ApiKey, BaseId)) { var response = await airtableBase.RetrieveRecord(table, recordId); if (response.Success) { myRecord = response.Record; } else if (response.AirtableApiError is AirtableApiException) { errorMessage = response.AirtableApiError.GetBaseException().Message; } else { errorMessage = "Error!"; } } var responseJson = JsonConvert.SerializeObject(myRecord); return(responseJson); }
public async Task ListRecordsMethodAsync(AirtableBase airtableBase, string offset) { Task <AirtableListRecordsResponse> task = airtableBase.ListRecords( tablename, offset, fieldsArray, filterByFormula, maxRecords, pageSize, sort, view); response = await task; if (response.AirtableApiError.ErrorMessage != null) { // Error reporting errorMessageString = response.AirtableApiError.DetailedErrorMessage2; } else { // Do something with the retrieved 'records' and the 'offset' // for the next page of the record list. } }
public async Task <IActionResult> GetCharts(string domainId, DeviceId deviceId) { using var airtableBase = new AirtableBase(_configuration["Airtable:Key"], _configuration["Airtable:Base"]); var redirectedToField = "RedirectedTo"; var creationTimeField = "CreationTime"; var records = await airtableBase.ListRecords("Views", fields : new[] { redirectedToField, creationTimeField }, filterByFormula : "AND({BaseDomain}='" + domainId + "', {RedirectedTo}='" + (deviceId == DeviceId.Mobile ? "Mobile" : "Desktop") + "')"); var typed = records.Records.Select(x => { return(new { RedirectedTo = x.Fields[redirectedToField], CreationDate = (DateTime)x.Fields[creationTimeField] }); }); var groupedByDay = typed .GroupBy(x => x.CreationDate.Date) .Select(x => new { Date = x.Key, Count = x.Count() }) .ToList(); var labelStr = string.Join("%2C", groupedByDay.Select(x => "%22" + x.Date.ToString("d") + "%22")); var dataStr = string.Join("%2C", groupedByDay.Select(x => x.Count.ToString())); return(Redirect( $"https://quickchart.io/chart?bkg=white&c=%7B%0A%20%20%22type%22%3A%20%22bar%22%2C%0A%20%20%22data%22%3A%20%7B%0A%20%20%20%20%22labels%22%3A%20%5B%0A%20%20%20%20%20%20{labelStr}%0A%20%20%20%20%5D%2C%0A%20%20%20%20%22datasets%22%3A%20%5B%0A%20%20%20%20%20%20%7B%0A%20%20%20%20%20%20%20%20%22label%22%3A%20%22Redirections%22%2C%0A%20%20%20%20%20%20%20%20%22backgroundColor%22%3A%20%22%23A83400%22%2C%0A%20%20%20%20%20%20%20%20%22data%22%3A%20%5B%0A%20%20%20%20%20%20%20%20%20%20{dataStr}%0A%20%20%20%20%20%20%20%20%5D%0A%20%20%20%20%20%20%7D%0A%20%20%20%20%5D%0A%20%20%7D%0A%7D")); }
public async Task <int> GetCount() { int count = 0; using (AirtableBase airtableBase = new AirtableBase(_appKey, _baseId)) { Task <AirtableListRecordsResponse <ViewersTable> > task = airtableBase.ListRecords <ViewersTable>( "Viewers"); AirtableListRecordsResponse <ViewersTable> response = await task; if (response.Success) { var viewers = new List <ViewersTable>(); var records = response.Records.ToList(); foreach (var rec in records) { var viewer = new ViewersTable { Name = rec.Fields.Name, PreferredPronoun = rec.Fields.PreferredPronoun, EmailAddress = rec.Fields.EmailAddress, StreamersWatched = rec.Fields.StreamersWatched }; viewers.Add(viewer); } var distinctViewers = viewers.GroupBy(g => new { g.EmailAddress }); count = distinctViewers.Count(); } } return(count); }
private SolveResults ListRecordsSolve(AirtableBase airtableBase, IGH_DataAccess DA) { SolveResults result = new SolveResults(); string offset = "0"; Task OutResponse = this.ListRecordsMethodAsync(airtableBase, offset, DA); result.Value = 1; return(result); }
protected override void SolveInstance(IGH_DataAccess DA) { // Declare a variable for the input String bool data = false; // Use the DA object to retrieve the data inside the first input parameter. // If the retieval fails (for example if there is no data) we need to abort. if (!DA.GetData(0, ref data)) { records.Clear(); return; } if (!DA.GetData(1, ref baseID)) { return; } if (!DA.GetData(2, ref appKey)) { return; } if (!DA.GetData(3, ref tablename)) { return; } if (!DA.GetData(4, ref view)) { return; } // If the retrieved data is Nothing, we need to abort. // We're also going to abort on a zero-length String. if (data == false) { records.Clear(); return; } AirtableBase airtableBase = new AirtableBase(appKey, baseID); Task OutResponse = ListRecordsMethodAsync(airtableBase); var responseString = OutResponse.ToString(); if (response != null) { if (response.Records != null) { records.AddRange(response.Records.ToList()); errorMessageString = "Success!"; } } // Use the DA object to assign a new String to the first output parameter. DA.SetData(0, errorMessageString); DA.SetDataList(1, records); }
public async Task <IActionResult> Get() { var host = Request.Host.ToString(); var isMobile = _deviceResolver.Device.Type == DeviceType.Mobile; var isCrawler = _crawlerResolver.Crawler != null; var type = isMobile ? "Mobile Redirection" : "Desktop Redirection"; var ip = HttpContext.Connection.RemoteIpAddress?.ToString(); var userAgent = Request.Headers["User-Agent"].ToString(); var referer = Request.Headers["Referer"].ToString(); var hasEntry = _memoryCache.TryGetValue <DomainMappingValue>(host, out var value); _ = Task.Run(async() => { using var airtableBaseInTask = new AirtableBase(_configuration["Airtable:Key"], _configuration["Airtable:Base"]); await airtableBaseInTask.CreateRecord("Views", new Fields { FieldsCollection = new Dictionary <string, object> { ["BaseDomain"] = host, ["Ip"] = ip, ["UserAgent"] = userAgent, ["RedirectedTo"] = isMobile ? "Mobile" : "Desktop", ["Referrer"] = referer } }); }); if (isCrawler && hasEntry) { var content = isMobile ? value.Mobile.Html : value.Desktop.Html; return(Content(content, "text/html")); } else { using var airtableBase = new AirtableBase(_configuration["Airtable:Key"], _configuration["Airtable:Base"]); var response = await airtableBase.ListRecords( "Redirections", fields : new[] { type }, filterByFormula : "{Base Address} = '" + host + "'", view : "Main", maxRecords : 1); if (!response.Success) { return(BadRequest()); } var airtableRecord = response.Records.FirstOrDefault(); if (airtableRecord == null) { return(BadRequest()); } var address = "https://" + airtableRecord.Fields[type]; return(base.Redirect(address)); } }
// STATUS [ July 13, 2019 ] : this works /// <summary> /// Get one record from a given table /// </summary> /// <remarks> /// Configuration for each table is setup in Startup.cs and airtableConfiguration.json /// See: https://github.com/ngocnicholas/airtable.net /// </remarks> /// <param name="tableName"> /// Equivalent to the TableName in airtableConfiguration.json /// Equivalent to the tab name in actual airtable /// </param> /// <param name="tableAuthenticationString"> /// Equivalent to the AuthenticationString in airtableConfiguration.json /// </param> /// <param name="recordId"> /// The airtable generated record Id /// This is visible thorugh the API but NOT in the actual table /// It is different than things like "Author_Id", "Record_Id", "Website_Id" /// </param> /// <example> /// var oneRecord = await _atM.GetOneRecordFromAirtableAsync("SpRankings", authenticationString, "rec7yJqKs5Ht3I7j3"); /// </example> public async Task <AirtableRecord> GetOneRecordFromAirtableAsync(string tableName, string tableAuthenticationString, string recordId) { using (AirtableBase airtableBase = new AirtableBase(_airtableConfig.ApiKey, tableAuthenticationString)) { Task <AirtableRetrieveRecordResponse> recordTask = airtableBase.RetrieveRecord(tableName, recordId); AirtableRetrieveRecordResponse recordTaskResponse = await recordTask.ConfigureAwait(false); AirtableRecord oneRecord = recordTaskResponse.Record; return(oneRecord); } }
public static async Task <bool> CheckHasPlayedSet(SdlPlayer player) { string offset = null; string errorMessage = null; List <AirtableRecord> records = new List <AirtableRecord>(); using (AirtableBase airtableBase = new AirtableBase(Globals.BotSettings.AppKey, Globals.BotSettings.BaseId)) { do { Logger.Info($"Retrieving data with offset {offset}."); Task <AirtableListRecordsResponse> task = airtableBase.ListRecords( "Draft Log", offset, null, null, null, null ); AirtableListRecordsResponse response = await task; if (response.Success) { Logger.Info($"Success! Continuing with offset \"{response.Offset}\""); records.AddRange(response.Records.ToList()); offset = response.Offset; } else if (response.AirtableApiError != null) { errorMessage = response.AirtableApiError.ErrorMessage; break; } else { errorMessage = "Unknown error"; break; } } while (offset != null); } if (!string.IsNullOrEmpty(errorMessage)) { SdlAirTableException airTableException = new SdlAirTableException( errorMessage, SdlAirTableException.AirtableErrorType.CommunicationError); Logger.Error(airTableException); throw airTableException; } return(records.Any(x => ((JArray)x.Fields["Alpha Players"]).Any(y => y.Value <string>() == player.AirtableId) || ((JArray)x.Fields["Bravo Players"]).Any(y => y.Value <string>() == player.AirtableId))); }
public async Task <AirtableListRecordsResponse> ListRecordsAsAsync() { AirtableListRecordsResponse response; using (AirtableBase airtableBase = new AirtableBase(appKey, baseId)) { Task <AirtableListRecordsResponse> task = airtableBase.ListRecords("Messages"); response = await task; } return(response); }
private static async Task <AirtableRecord[]> GetAllPlayerRecords() { string offset = null; string errorMessage = null; List <AirtableRecord> records = new List <AirtableRecord>(); using (AirtableBase airtableBase = new AirtableBase(Globals.BotSettings.AppKey, Globals.BotSettings.BaseId)) { do { Logger.Info($"Retrieving data with offset {offset}."); Task <AirtableListRecordsResponse> task = airtableBase.ListRecords( "Draft Standings", offset, null, null, null, null ); AirtableListRecordsResponse response = await task; if (response.Success) { Logger.Info($"Success! Continuing with offset \"{response.Offset}\""); records.AddRange(response.Records.ToList()); offset = response.Offset; } else if (response.AirtableApiError != null) { errorMessage = response.AirtableApiError.ErrorMessage; break; } else { errorMessage = "Unknown error"; break; } } while (offset != null); } if (!string.IsNullOrEmpty(errorMessage)) { SdlAirTableException airTableException = new SdlAirTableException( errorMessage, SdlAirTableException.AirtableErrorType.CommunicationError); Logger.Error(airTableException); throw airTableException; } return(records.ToArray()); }
private static async Task <List <AirtableRecord> > GetAirTableDataAsync(string table, List <string> fields, string view = null) { string offset = null; string errorMessage = null; var records = new List <AirtableRecord>(); using (AirtableBase airtableBase = new AirtableBase(appKey, baseId)) { // // Use 'offset' and 'pageSize' to specify the records that you want // to retrieve. // Only use a 'do while' loop if you want to get multiple pages // of records. // do { Task <AirtableListRecordsResponse> task = airtableBase.ListRecords( table, offset, fields, null, null, null, null, view); AirtableListRecordsResponse response = await task; if (response.Success) { records.AddRange(response.Records.ToList()); offset = response.Offset; } else if (response.AirtableApiError is AirtableApiException) { errorMessage = response.AirtableApiError.ErrorMessage; break; } else { errorMessage = "Unknown error"; break; } } while (offset != null); } if (!string.IsNullOrEmpty(errorMessage)) { // Error reporting throw new Exception(errorMessage); } else { // Do something with the retrieved 'records' and the 'offset' // for the next page of the record list. return(records); } }
const string API_KEY = "keyvJVU4lZksGnWhI"; // airtable api key for tests public static ATTable GetData(string APPLICATION_ID, string TABLE_NAME) { string BASE_URL = $"https://api.airtable.com/v0/{APPLICATION_ID}/{Uri.EscapeUriString(TABLE_NAME)}"; ATTable at = new ATTable(TABLE_NAME); try { AirtableBase airtableBase = new AirtableBase(API_KEY, APPLICATION_ID); var task = airtableBase.ListRecords(TABLE_NAME); TaskHelper.RunTaskSynchronously(task); AirtableListRecordsResponse response = task.Result; if (null == response || response.Records == null) { return(at); } foreach (AirtableRecord rd in response.Records) { int index = int.Parse(rd.GetField("Index").ToString()); ATRow row = new ATRow(index, TABLE_NAME); IEnumerable <AirtableAttachment> attaches = rd.GetAttachmentField("Photo"); if (null != attaches && attaches.Count() > 0) { row.PhotoAttach = attaches.First(); } foreach (KeyValuePair <string, object> pair in rd.Fields) { if (pair.Key != "Index" && pair.Key != "Photo") { row.Descriptions.Add(pair.Value.ToString()); } } if (!row.IsEmpty()) { at.Rows.Add(row); } } } catch (Exception ex) { MessageBox.Show(ex.ToString()); } return(at); }
public async Task <IActionResult> GetRepartitionChart(string domainId) { using var airtableBase = new AirtableBase(_configuration["Airtable:Key"], _configuration["Airtable:Base"]); var redirectedToField = "RedirectedTo"; var records = await airtableBase.ListRecords("Views", fields : new[] { redirectedToField }, filterByFormula : "{BaseDomain}='" + domainId + "'"); var mobileCount = records.Records.Count(x => x.Fields[redirectedToField].ToString() == "Mobile"); var desktopCount = records.Records.Count(x => x.Fields[redirectedToField].ToString() == "Desktop"); return(Redirect( $"https://quickchart.io/chart?bkg=white&c=%7B%0A%20%20type%3A%20%27doughnut%27%2C%0A%20%20data%3A%20%7B%0A%20%20%20%20datasets%3A%20%5B%0A%20%20%20%20%20%20%7B%0A%20%20%20%20%20%20%20%20data%3A%20%5B{mobileCount}%2C%20{desktopCount}%5D%2C%0A%20%20%20%20%20%20%20%20backgroundColor%3A%20%5B%0A%20%20%20%20%20%20%20%20%20%20%27%23A83400%27%2C%0A%20%20%20%20%20%20%20%20%20%20%27rgb(255%2C%20159%2C%2064)%27%2C%0A%20%20%20%20%20%20%20%20%5D%2C%0A%20%20%20%20%20%20%20%20label%3A%20%27Dataset%201%27%2C%0A%20%20%20%20%20%20%7D%2C%0A%20%20%20%20%5D%2C%0A%20%20%20%20labels%3A%20%5B%27Mobile%27%2C%20%27Desktop%27%5D%2C%0A%20%20%7D%0A%7D%0A")); }
public static async Task SetFriendCodeAsync(SdlPlayer player, string code) { using (AirtableBase airtableBase = new AirtableBase(Globals.BotSettings.AppKey, Globals.BotSettings.BaseId)) { Fields fields = new Fields(); fields.AddField("Friend Code", code); AirtableCreateUpdateReplaceRecordResponse response = await airtableBase.UpdateRecord("Draft Standings", fields, player.AirtableId, true); if (!response.Success) { Logger.Error(response.AirtableApiError.ErrorMessage); } } }
public async Task <AirtableCreateUpdateReplaceRecordResponse> CreateRecordAsAsync(LogMessage msg) { AirtableCreateUpdateReplaceRecordResponse response; using (AirtableBase airtableBase = new AirtableBase(appKey, baseId)) { var fields = new Fields(); fields.AddField(Constants.ID, msg.Id); fields.AddField(Constants.SUMMARY, msg.Title); fields.AddField(Constants.MESSAGE, msg.Text); fields.AddField(Constants.RECEIVEDAT, msg.ReceivedAt); Task <AirtableCreateUpdateReplaceRecordResponse> task = airtableBase.CreateRecord("Messages", fields, true); response = await task; } return(response); }
public Result Execute( ExternalCommandData commandData, ref string message, ElementSet elements) { UIApplication uiapp = commandData.Application; UIDocument uidoc = uiapp.ActiveUIDocument; Application app = uiapp.Application; Document doc = uidoc.Document; string configPath = @"C:\Temp\AirtableSettings.csv"; try { Dictionary <string, Helpers.CardContent> dashboardDictionary = Helpers.ModelStatus(doc); List <string> apiAndKeys = Helpers.GetAirtableKeys(configPath); string baseId = apiAndKeys[0]; string appKey = apiAndKeys[1]; var fields = new Fields(); foreach (var dict in dashboardDictionary) { fields.AddField(dict.Key, dict.Value.Value); } AirtableBase airtableBase = new AirtableBase(appKey, baseId); //var listRecords = GetRecords(airtableBase, "Model Status", records, errorMessage); var create = Helpers.CreateRecord(airtableBase, "Model Status", fields); Task.Run(() => create); //Task.WaitAll(listRecords, create); //Task.WaitAll(create); return(Result.Succeeded); } catch (Exception ex) { TaskDialog.Show("Error", ex.Message); return(Result.Failed); } }