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 <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");
}
}
//=========================== 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 CreateAfk(AfkObject data)
{
Fields field = new Fields();
field.AddField("id", data.Id);
field.AddField("isAfk", data.IsAfk);
field.AddField("message", data.Message);
await Base.CreateRecord(table, field);
}
public async Task UpdateWaifus(WaifuObject data)
{
Fields field = new Fields();
field.AddField("Waifus", data.Waifus);
field.AddField("Feeds", data.Feeds);
field.AddField("Levels", data.Levels);
field.AddField("Lewds", data.Lewds);
field.AddField("LastModifiedHour", data.LastModifiedHour);
await Base.UpdateRecord(table, field, data.RecordId);
}
public Fields GetFields()
{
var fields = new Fields();
fields.AddField("Name", Name);
fields.AddField("Description", Description);
fields.AddField("Is Active", IsActive);
fields.AddField("Email Address", EmailAddress);
return(fields);
}
private static IFields createFields(string string_0, string string_1, bool bool_0,
ISpatialReference ispatialReference_0, ISpatialReference ispatialReference_1)
{
IFieldsEdit edit = new Fields() as IFieldsEdit;
edit.AddField(createOIDField("ObjectID"));
edit.AddField(createNameField("name"));
edit.AddField(createRasterField(string_0, bool_0, ispatialReference_1));
edit.AddField(createShapeField(string_1, ispatialReference_0));
return(edit);
}
public async Task UpdateAfk(AfkObject data)
{
Fields field = new Fields();
field.AddField("isAfk", data.IsAfk);
field.AddField("message", data.Message);
var result = await Base.UpdateRecord(table, field, data.RecordId);
Console.WriteLine($"Update AFK Result: {result.Success}");
Console.WriteLine($"Error: {result.AirtableApiError}");
}
private void LogInventoryEntry(string entryName, string componentID, int quantityChange, string orderID = "")
{
var logFields = new Fields();
logFields.AddField("Name", entryName);
logFields.AddField("Items", new JArray {
componentID
});
logFields.AddField("Quantity Change", quantityChange);
logFields.AddField("OrderID", orderID);
var task = _invAirtableBase.CreateRecord(logFieldName, logFields);
var response = task.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 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);
}
private Fields GetFields(MessageDTO messageDTO)
{
var fields = new Fields();
foreach (PropertyInfo pi in messageDTO.GetType().GetProperties())
{
fields.AddField(pi.Name, pi.GetValue(messageDTO, null)?.ToString());
}
return(fields);
}
public static async Task RegisterPlayer(ulong discordId, double startingPowerLevel, string nickname)
{
using (AirtableBase airtableBase = new AirtableBase(Globals.BotSettings.AppKey, Globals.BotSettings.BaseId))
{
Fields fields = new Fields();
fields.AddField("Name", nickname);
fields.AddField("DiscordID", discordId.ToString());
fields.AddField("Starting Power", startingPowerLevel);
if ((await GetAllPlayerRecords()).All(e =>
e.Fields["DiscordID"].ToString() != discordId.ToString(CultureInfo.InvariantCulture)))
{
AirtableCreateUpdateReplaceRecordResponse response =
await airtableBase.CreateRecord("Draft Standings", fields, true);
if (!response.Success)
{
Console.WriteLine(response.AirtableApiError.ErrorMessage);
}
}
}
}
public async Task CreateRecordsIntoAirtable()
{
using (AirtableBase airtableBase = new AirtableBase(appKey, baseId))
{
// Create Attachments list
//var attachmentList = new List<AirtableAttachment>();
//attachmentList.Add(new AirtableAttachment { Url = "https://upload.wikimedia.org/wikipedia/en/d/d1/Picasso_three_musicians_moma_2006.jpg" });
var fields = new Fields();
fields.AddField("User Email", "Pablo Picasso");
fields.AddField("Notes", "Spanish expatriate Pablo Picasso was one of the greatest and most influential artists of the 20th century, as well as the co-creator of Cubism.");
//fields.AddField("Attachments", attachmentList);
//fields.AddField("On Display?", false);
Task <AirtableCreateUpdateReplaceRecordResponse> task = airtableBase.CreateRecord("New Users", fields, true);
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 created record.
}
}
}
public void AddImageToProduct(InventoryProduct product, string imageURL = "")
{
//Task<AirtableRetrieveRecordResponse> task = _invAirtableBase.RetrieveRecord(ProductsTableName, product.Record.Id);
//var response = task.Result;
Fields mainField = new Fields();
Fields imgField = new Fields();
imgField.AddField("url", imageURL);
mainField.AddField("Image", imgField);
var updateTask = _invAirtableBase.UpdateRecord(ProductsTableName, mainField, product.Record.Id);
var updateResponse = updateTask.Result;
}
public bool UpdateCompletedOrderComponentEntries(string orderID)
{
string offset = "";
string query = "{OrderID} = '" + orderID + "'";
//mark component entries for the completed order as shipped
Task <AirtableListRecordsResponse> task = _invAirtableBase.ListRecords(logFieldName, offset, null, query);
foreach (var logRecord in task.Result.Records)
{
var logFields = new Fields();
logFields.AddField("Shipped", true);
var updateTask = _invAirtableBase.UpdateRecord(logFieldName, logFields, logRecord.Id);
var response = updateTask.Result;
}
return(true);
}
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 CreateCooldowns(CooldownObject data)
{
Fields field = new Fields();
field.AddField("Daily", data.Daily);
field.AddField("Bless", data.Bless);
field.AddField("Pluck", data.Pluck);
field.AddField("Vote", data.Vote);
field.AddField("Work", data.Work);
field.AddField("Thievery", data.Thievery);
field.AddField("userId", data.Id);
await Base.CreateRecord(table, field);
}
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);
}
}
public string GetMonthlyID(DateTime date)
{
var currentMonth = date.ToString("MM/yyyy");
Fields fields = new Fields();
fields.AddField(nameKey, currentMonth);
var dict = GetMonthlyEntries();
if (dict.ContainsKey(currentMonth))
{
return(dict[currentMonth]);
}
else
{
Task <AirtableCreateUpdateReplaceRecordResponse> task = _mainAirtableBase.CreateRecord(TableName, fields);
var response = task.Result;
return(task.Result.Record.Id);
}
}
public async Task <bool> UpdateRecord(string recordId, IDictionary <string, object> valuesToUpdate)
{
_logger.LogTrace($"{GetType()} - BEGIN {nameof(UpdateRecord)}");
using (AirtableBase airtableBase = new AirtableBase(_config.ApiKey, _config.DatabaseId))
{
Fields f = new Fields();
foreach (KeyValuePair <string, object> kvp in valuesToUpdate)
{
f.AddField(kvp.Key, kvp.Value);
}
AirtableCreateUpdateReplaceRecordResponse res = await airtableBase.UpdateRecord(_config.TableName, f, recordId);
if (res.Success)
{
return(true);
}
else
{
_logger.LogError(res.AirtableApiError, $"Une erreur est survenue pendant la mise à jour d'un enregistrement Airtable : {res.AirtableApiError.ErrorName} [{res.AirtableApiError.ErrorCode}] : {res.AirtableApiError.ErrorMessage}");
return(false);
}
}
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
ILogger log)
{
log.LogInformation("C# HTTP trigger function processed a request.");
string rotation = await new StreamReader(req.Body).ReadToEndAsync();
using (AirtableBase airtableBase = new AirtableBase(
Environment.GetEnvironmentVariable("airtableApiKey"),
Environment.GetEnvironmentVariable("airtableBaseId")))
{
log.LogInformation("Airtable connection initialized.");
var rotationNumber = int.Parse(new Regex(@"(^\d+)", RegexOptions.Multiline).Match(rotation).Groups[1].Value);
var rotationStartDateString = new Regex(@" (\d{2}[A-Z]{3})").Match(rotation).Groups[1].Value;
var rotationStartDate = monthConverter[rotationStartDateString.Substring(2, 3)] + "/" +
int.Parse(rotationStartDateString.Substring(0, 2)) + "/" +
DateTime.Now.Year;
var rotationNumberOfAttendants = new Regex(@"([0-9]+) F\/A").Match(rotation).Groups[1].Value;
log.LogInformation($"Parsed rotation #{rotationNumber}-{rotationStartDate}.");
// Update rotation
log.LogInformation("Updating rotation.");
var rotationRecordId = req.Headers["Airtable-Record-Id"][0];
var rotationLookup = airtableBase.RetrieveRecord("Rotations", rotationRecordId).GetAwaiter().GetResult();
if (!rotationLookup.Success)
{
log.LogError(rotationLookup.AirtableApiError.ErrorMessage);
return(new StatusCodeResult(500));
}
log.LogInformation("Looked up rotation successfully.");
var rotationFields = new Fields();
rotationFields.AddField("Rotation #", rotationNumber);
rotationFields.AddField("Date", rotationStartDate);
var rotationUpdate = airtableBase.UpdateRecord("People", rotationFields, rotationRecordId).GetAwaiter().GetResult();
if (!rotationUpdate.Success)
{
log.LogError(rotationUpdate.AirtableApiError.ErrorMessage);
return(new StatusCodeResult(500));
}
log.LogInformation("Updated rotation successfully.");
// Add flight attendants
for (int i = 0; i < int.Parse(rotationNumberOfAttendants); i++)
{
log.LogInformation($"Starting to process flight attendant {i}.");
var flightAttendantRecord = new Regex($@"^{Convert.ToChar(65 + i)} 0([0-9]*) ([A-Za-z]*)([A-Za-z ]*)", RegexOptions.Multiline).Match(rotation);
var faEmployeeId = int.Parse(flightAttendantRecord.Groups[1].Value);
var faLookup = airtableBase.ListRecords("People", null, null, $"{{Employee ID}} = {faEmployeeId}").GetAwaiter().GetResult();
if (!faLookup.Success)
{
log.LogError(faLookup.AirtableApiError.ErrorMessage);
return(new StatusCodeResult(500));
}
log.LogInformation($"Looked up flight attendant {faLookup} successfully.");
if (!faLookup.Records.Any())
{
log.LogInformation("Adding flight attendant.");
var fields = new Fields();
fields.AddField("Employee ID", faEmployeeId);
fields.AddField("First name", flightAttendantRecord.Groups[2].Value);
fields.AddField("Last name", flightAttendantRecord.Groups[3].Value);
var result = airtableBase.CreateRecord("People", fields).GetAwaiter().GetResult();
if (!result.Success)
{
log.LogError(result.AirtableApiError.ErrorMessage);
return(new StatusCodeResult(500));
}
log.LogInformation("Added flight attendant successfully.");
}
else
{
log.LogInformation("Flight attendant already registered.");
}
}
}
return((ActionResult) new OkResult());
}
public static void ExtractSelectFeatureFormLayer(IFeatureLayer ifeatureLayer_0,
IFeatureWorkspace ifeatureWorkspace_0, IGeometry igeometry_0)
{
IEnumFieldError enumFieldError;
IFields field;
string str;
ICursor cursor;
try
{
IFeatureSelection ifeatureLayer0 = (IFeatureSelection)ifeatureLayer_0;
if (ifeatureLayer0.SelectionSet.Count != 0)
{
IFeatureClass featureClass = ifeatureLayer_0.FeatureClass;
IFields fields = featureClass.Fields;
IFieldChecker fieldCheckerClass = new FieldChecker()
{
InputWorkspace = (featureClass as IDataset).Workspace,
ValidateWorkspace = ifeatureWorkspace_0 as IWorkspace
};
fieldCheckerClass.Validate(fields, out enumFieldError, out field);
enumFieldError.Reset();
IFieldError fieldError = enumFieldError.Next();
string str1 = "";
while (fieldError != null)
{
fieldError.FieldError.ToString();
IField field1 = fields.Field[fieldError.FieldIndex];
IField field2 = field.Field[fieldError.FieldIndex];
string str2 = str1;
string[] name = new string[] { str2, field2.Name, " reason: ", field1.Name, " " };
str1 = string.Concat(name);
fieldError = enumFieldError.Next();
}
Hashtable hashtables = new Hashtable();
string name1 = ifeatureLayer_0.Name;
char chr = name1[0];
if ((chr < '0' ? false : chr <= '9'))
{
name1 = string.Concat("A", name1);
}
fieldCheckerClass.ValidateTableName(name1, out str);
name1 = str;
string name2 = "";
IFieldsEdit fieldsClass = new Fields() as IFieldsEdit;
for (int i = field.FieldCount - 1; i >= 0; i--)
{
IField field3 = field.Field[i];
if (field3.Type == esriFieldType.esriFieldTypeGeometry)
{
name2 = field3.Name;
IGeometryDef geometryDef = field3.GeometryDef;
ISpatialReference spatialReference =
(geometryDef.SpatialReference as IClone).Clone() as ISpatialReference;
SpatialReferenctOperator.ChangeCoordinateSystem(ifeatureWorkspace_0 as IGeodatabaseRelease,
spatialReference, false);
(geometryDef as IGeometryDefEdit).SpatialReference_2 = spatialReference;
(field3 as IFieldEdit).GeometryDef_2 = geometryDef;
}
if ((ifeatureWorkspace_0 as IWorkspace).Type != esriWorkspaceType.esriFileSystemWorkspace)
{
fieldsClass.AddField(field3);
}
else if (field3.Type != esriFieldType.esriFieldTypeBlob)
{
fieldsClass.AddField(field3);
}
}
IFeatureClass featureClass1 = null;
try
{
featureClass1 = ifeatureWorkspace_0.CreateFeatureClass(name1, fieldsClass, null, null,
esriFeatureType.esriFTSimple, name2, "");
}
catch (Exception exception)
{
MessageBox.Show("无法创建输出要素类!");
return;
}
IFeatureCursor featureCursor = null;
IFeatureCursor featureCursor1 = featureClass1.Insert(true);
IFeatureBuffer featureBuffer = featureClass1.CreateFeatureBuffer();
ifeatureLayer0.SelectionSet.Search(null, false, out cursor);
featureCursor = (IFeatureCursor)cursor;
for (IFeature j = featureCursor.NextFeature(); j != null; j = featureCursor.NextFeature())
{
if (j.Shape != null)
{
Clip.InsertFeature(featureCursor1, featureBuffer, field, j, j.Shape, igeometry_0);
}
}
featureCursor1.Flush();
Marshal.ReleaseComObject(featureBuffer);
featureBuffer = null;
Marshal.ReleaseComObject(featureCursor1);
featureCursor1 = null;
}
}
catch
{
}
}
async private void AirtableSendRecords()
{
int RecordCount = 0;
int NewCount = 0;
int UpdatedCount = 0;
using (AirtableBase airtableBase = new AirtableBase(App.AirtableKey, App.AirtableBase))
{
List <Fields> newRecordList = new List <Fields>();
List <IdFields> updatedRecordList = new List <IdFields>();
foreach (EventTeamMatch match in App.Database.GetEventTeamMatchesAsync().Result)
{
// only send matches from this event
if (match.EventKey != App.currFRCEventKey)
{
continue;
}
// only send matches from this device
if (match.DeviceName != App.KindleName)
{
continue;
}
RecordCount++;
if (string.IsNullOrEmpty(match.AirtableId))
{
Fields fields = new Fields();
JObject jo = match.ToJson();
foreach (KeyValuePair <string, object> kv in jo.ToList())
{
if (kv.Key == "Id" || kv.Key == "AirtableId")
{
continue;
}
fields.AddField(kv.Key, kv.Value);
}
newRecordList.Add(fields);
}
else
{
if (match.Changed % 2 == 0) // even, don't upload
{
continue;
}
match.Changed++; // make even
IdFields fields = new IdFields(match.AirtableId.ToString());
JObject jo = match.ToJson();
foreach (KeyValuePair <string, object> kv in jo.ToList())
{
if (kv.Key == "Id" || kv.Key == "AirtableId")
{
continue;
}
fields.AddField(kv.Key, kv.Value);
}
updatedRecordList.Add(fields);
}
}
if (newRecordList.Count > 0)
{
int tempCount = await AirtableSendNewRecords(airtableBase, newRecordList);
if (tempCount < 0)
{
return; // error, exit out
}
NewCount += tempCount;
}
if (updatedRecordList.Count > 0)
{
int tempCount = await AirtableSendUpdatedRecords(airtableBase, updatedRecordList);
if (tempCount < 0)
{
return; // error, exit out
}
UpdatedCount += tempCount;
}
}
Label_Results.Text = $"Records found: {RecordCount}\r\n";
Label_Results.Text += $"New records: {NewCount}\r\n";
Label_Results.Text += $"Updated records: {UpdatedCount}";
}
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 static async Task PenalizePlayer(ulong discordId, int points, string notes)
{
AirtableRecord playerRecord = await GetPlayerRecord(discordId);
using (AirtableBase airtableBase = new AirtableBase(Globals.BotSettings.AppKey, Globals.BotSettings.BaseId))
{
Fields adjustmentsFields = new Fields();
adjustmentsFields.AddField("Player", playerRecord.Id);
adjustmentsFields.AddField("Points", -points);
adjustmentsFields.AddField("Notes", notes);
Task <AirtableCreateUpdateReplaceRecordResponse> createRecordTask =
airtableBase.CreateRecord("Adjustments", adjustmentsFields, true);
AirtableCreateUpdateReplaceRecordResponse createRecordResponse = await createRecordTask;
if (!createRecordResponse.Success)
{
string errorMessage = createRecordResponse.AirtableApiError != null
? createRecordResponse.AirtableApiError.ErrorMessage
: "Unknown error";
SdlAirTableException exception = new SdlAirTableException(
errorMessage,
SdlAirTableException.AirtableErrorType.CommunicationError);
Logger.Error(exception);
throw exception;
}
AirtableRecord record = createRecordResponse.Record;
if (!playerRecord.Fields.ContainsKey("Adjustments"))
{
playerRecord.Fields["Adjustments"] = new JArray();
}
IEnumerable <JToken> updatedAdjustmentIds = ((JArray)playerRecord.Fields["Adjustments"]).Append(record.Id);
Fields updatePlayerFields = new Fields();
updatePlayerFields.AddField("Adjustments", updatedAdjustmentIds.ToArray());
Task <AirtableCreateUpdateReplaceRecordResponse> updateRecordTask =
airtableBase.UpdateRecord("Draft Standings", updatePlayerFields, playerRecord.Id, true);
AirtableCreateUpdateReplaceRecordResponse updateRecordResponse = await updateRecordTask;
if (!updateRecordResponse.Success)
{
string errorMessage = updateRecordResponse.AirtableApiError != null
? updateRecordResponse.AirtableApiError.ErrorMessage
: "Unknown error";
SdlAirTableException exception = new SdlAirTableException(
errorMessage,
SdlAirTableException.AirtableErrorType.CommunicationError);
Logger.Error(exception);
throw exception;
}
}
}
private void simpleButton1_Click(object sender, EventArgs e)
{
if (Validate(true) == false)
{
return;
}
string locType = label1.Tag != null?label1.Tag.ToString() : "";
if (string.IsNullOrEmpty(locType))
{
return;
}
object createLoc;
IWorkspace2 workspace2 = null;
IObjectTemplate template = null;
if (_isSingle)
{
template = _template;
}
else
{
template = _plugin.TemplateDatabase.Templates.FirstOrDefault(c => c.Name == cmbTemplate.SelectedItem.ToString());
}
if (template == null)
{
return;
}
if (locType.Contains("Dataset"))
{
IGxDataset pDataset = txtDB.Tag as IGxDataset;
IFeatureDataset fDataset = ((IGxObject)pDataset).InternalObjectName.Open();
workspace2 = fDataset.Workspace as IWorkspace2;
createLoc = fDataset;
}
else
{
IGxDatabase pDatabase = txtDB.Tag as IGxDatabase;
IFeatureWorkspace workspace = ((IGxObject)pDatabase).InternalObjectName.Open();
workspace2 = workspace as IWorkspace2;
createLoc = workspace;
}
if (createLoc == null)
{
return;
}
string fcName = txtName.EditValue.ToString().Trim();
IWorkspace2 workSpace2 = createLoc is IFeatureDataset
? ((IFeatureDataset)createLoc).Workspace as IWorkspace2
: createLoc as IWorkspace2;
if (workSpace2.NameExists[esriDatasetType.esriDTFeatureClass, fcName])
{
MessageService.Current.Warn("该名称已经存在，请重新输入！");
return;
}
ISpatialReference pSpatialReference = _map.SpatialReference;
IFieldsEdit pFieldsEdit = new Fields() as IFieldsEdit;
IField pField = FieldHelper.CreateOIDField();
pFieldsEdit.AddField(pField);
if (locType.Contains("Dataset"))
{
IGeoDataset pFDataset = createLoc as IGeoDataset;
pField = FieldHelper.CreateGeometryField(template.GeometryType, pFDataset.SpatialReference);
pSpatialReference = pFDataset.SpatialReference;
pFieldsEdit.AddField(pField);
}
else
{
pField = FieldHelper.CreateGeometryField(template.GeometryType, _map.SpatialReference);
pFieldsEdit.AddField(pField);
}
string keyName = "";
foreach (YTField ytField in template.Fields)
{
pField = ytField.CreateField();
pFieldsEdit.AddField(pField);
if (ytField.IsKey)
{
keyName = ytField.Name;
}
}
IFeatureClass pClass = WorkspaceOperator.CreateFeatureClass(createLoc, txtName.Text, pSpatialReference, template.FeatureType,
template.GeometryType, (IFields)pFieldsEdit, null, null, "");
if (pClass == null)
{
MessageService.Current.Info("创建失败!");
return;
}
if (pClass != null && chkIndex.Checked == false)
{
MapHelper.AddFeatureLayer((IBasicMap)_map, pClass);
MessageService.Current.Info("创建成功并已经加载图层!");
DialogResult = DialogResult.OK;
return;
}
IEnvelope pEnv = new Envelope() as IEnvelope;
pEnv.PutCoords(Convert.ToDouble(txtXMin.Text), Convert.ToDouble(txtYMin.Text), Convert.ToDouble(txtXMax.Text), Convert.ToDouble(txtYMax.Text));
IWorkspaceEdit pWksEdit = ((IDataset)pClass).Workspace as IWorkspaceEdit;
pWksEdit.StartEditing(false);
pWksEdit.StartEditOperation();
IndexHelper.CreateGridIndex(pClass, pEnv, Convert.ToDouble(txtWidth.Text),
Convert.ToDouble(txtHeight.Text), keyName);
pWksEdit.StopEditOperation();
pWksEdit.StopEditing(true);
MapHelper.AddFeatureLayer((IBasicMap)_map, pClass);
MessageService.Current.Info("创建成功并已经加载图层!");
DialogResult = DialogResult.OK;
}
public static void ExtractSelectFeatureFormLayer(IFeatureLayer ifeatureLayer_0,
IFeatureWorkspace ifeatureWorkspace_0, IGeometry igeometry_0)
{
try
{
IFeatureSelection featureSelection = (IFeatureSelection)ifeatureLayer_0;
if (featureSelection.SelectionSet.Count != 0)
{
IFeatureClass featureClass = ifeatureLayer_0.FeatureClass;
IFields fields = featureClass.Fields;
IFieldChecker fieldChecker = new FieldChecker();
fieldChecker.InputWorkspace = (featureClass as IDataset).Workspace;
fieldChecker.ValidateWorkspace = (ifeatureWorkspace_0 as IWorkspace);
IEnumFieldError enumFieldError;
IFields fields2;
fieldChecker.Validate(fields, out enumFieldError, out fields2);
enumFieldError.Reset();
IFieldError fieldError = enumFieldError.Next();
string text = "";
while (fieldError != null)
{
fieldError.FieldError.ToString();
IField field = fields.get_Field(fieldError.FieldIndex);
IField field2 = fields2.get_Field(fieldError.FieldIndex);
string text2 = text;
text = string.Concat(new string[]
{
text2,
field2.Name,
" reason: ",
field.Name,
" "
});
fieldError = enumFieldError.Next();
}
new Hashtable();
string text3 = ifeatureLayer_0.Name;
string text4;
fieldChecker.ValidateTableName(text3, out text4);
text3 = text4;
string shapeFieldName = "";
IFieldsEdit fieldsEdit = new Fields() as IFieldsEdit;
for (int i = fields2.FieldCount - 1; i >= 0; i--)
{
IField field3 = fields2.get_Field(i);
if (field3.Type == esriFieldType.esriFieldTypeGeometry)
{
shapeFieldName = field3.Name;
IGeometryDef geometryDef = field3.GeometryDef;
ISpatialReference spatialReference =
(geometryDef.SpatialReference as IClone).Clone() as ISpatialReference;
SpatialReferenctOperator.ChangeCoordinateSystem(ifeatureWorkspace_0 as IGeodatabaseRelease,
spatialReference, false);
(geometryDef as IGeometryDefEdit).SpatialReference_2 = spatialReference;
(field3 as IFieldEdit).GeometryDef_2 = geometryDef;
}
if ((ifeatureWorkspace_0 as IWorkspace).Type == esriWorkspaceType.esriFileSystemWorkspace)
{
if (field3.Type != esriFieldType.esriFieldTypeBlob)
{
fieldsEdit.AddField(field3);
}
}
else
{
fieldsEdit.AddField(field3);
}
}
IFeatureClass featureClass2 = null;
try
{
featureClass2 = ifeatureWorkspace_0.CreateFeatureClass(text3, fieldsEdit, null, null,
esriFeatureType.esriFTSimple, shapeFieldName, "");
}
catch (Exception)
{
System.Windows.Forms.MessageBox.Show("无法创建输出要素类!");
return;
}
IFeatureCursor featureCursor = featureClass2.Insert(true);
IFeatureBuffer featureBuffer = featureClass2.CreateFeatureBuffer();
ICursor cursor;
featureSelection.SelectionSet.Search(null, false, out cursor);
IFeatureCursor featureCursor2 = (IFeatureCursor)cursor;
for (IFeature feature = featureCursor2.NextFeature();
feature != null;
feature = featureCursor2.NextFeature())
{
if (feature.Shape != null)
{
ClipHelper.InsertFeature(featureCursor, featureBuffer, fields2, feature, feature.Shape,
igeometry_0);
}
}
featureCursor.Flush();
Marshal.ReleaseComObject(featureBuffer);
Marshal.ReleaseComObject(featureCursor);
}
}
catch
{
}
}
public async Task CreateUserProfile(UserObject data)
{
Fields field = new Fields();
field.AddField("ID", data.Id);
field.AddField("Disable", data.Disable);
field.AddField("balance", data.Balance);
field.AddField("xp", data.Xp);
field.AddField("level", data.Level);
field.AddField("votes", data.Votes);
field.AddField("description", data.Description);
field.AddField("background", data.Background);
field.AddField("birthday", data.Birthday);
field.AddField("marry", data.Marry);
field.AddField("ownBgName", data.OwnBgNames);
field.AddField("ownBgUrl", data.OwnBgUrl);
field.AddField("weekly", data.OwnBgNames);
await Base.CreateRecord(table, field);
}
private IFields GetFields(esriGeometryType geomType, IDomain domain)
{
IFieldsEdit fields = new Fields() as IFieldsEdit;
IFieldEdit field = new Field() as IFieldEdit;
field.AliasName_2 = "Feature ID";
field.Name_2 = "FeatureID";
field.Type_2 = esriFieldType.esriFieldTypeString;
field.Length_2 = 100;
fields.AddField(field);
field = new Field() as IFieldEdit;
field.AliasName_2 = "Feature ID Field";
field.Name_2 = "FeatureIDField";
field.Type_2 = esriFieldType.esriFieldTypeString;
field.Length_2 = 100;
fields.AddField(field);
field = new Field() as IFieldEdit;
field.AliasName_2 = "Job ID";
field.Name_2 = "JobID";
field.Type_2 = esriFieldType.esriFieldTypeInteger;
field.Precision_2 = 10;
fields.AddField(field);
field = new Field() as IFieldEdit;
field.AliasName_2 = "Logged By";
field.Name_2 = "LoggedBy";
field.Type_2 = esriFieldType.esriFieldTypeString;
field.Length_2 = 100;
fields.AddField(field);
field = new Field() as IFieldEdit;
field.AliasName_2 = "Table Name";
field.Name_2 = "TableName";
field.Type_2 = esriFieldType.esriFieldTypeString;
field.Length_2 = 100;
fields.AddField(field);
field = new Field() as IFieldEdit;
field.AliasName_2 = "Transaction Type";
field.Name_2 = "TransactionType";
field.Type_2 = esriFieldType.esriFieldTypeInteger;
field.Domain_2 = domain;
fields.AddField(field);
field = new Field() as IFieldEdit;
field.AliasName_2 = "Transaction Date";
field.Name_2 = "TransactionDate";
field.Type_2 = esriFieldType.esriFieldTypeDate;
fields.AddField(field);
field = new Field() as IFieldEdit;
field.AliasName_2 = "Attributes";
field.Name_2 = "Attributes";
field.Type_2 = esriFieldType.esriFieldTypeString;
field.Length_2 = 5000;
fields.AddField(field);
field = new Field() as IFieldEdit;
field.AliasName_2 = "Session ID";
field.Name_2 = "SessionID";
field.Type_2 = esriFieldType.esriFieldTypeInteger;
field.Precision_2 = 10;
fields.AddField(field);
field = new Field() as IFieldEdit;
IGeometryDefEdit geomDef = new GeometryDef() as IGeometryDefEdit;
geomDef.GeometryType_2 = geomType;
geomDef.SpatialReference_2 = GetSpatialReference();
geomDef.HasM_2 = false;
geomDef.HasZ_2 = false;
field.Name_2 = "SHAPE";
field.Type_2 = esriFieldType.esriFieldTypeGeometry;
field.GeometryDef_2 = geomDef;
fields.AddField(field);
return(fields);
}
