public async Task <UpdateItemResponse> UpdateItem(UpdateItemRequest item)
{
string url = $"/item/update";
var requestBody = await Task.Run(() => JsonConvert.SerializeObject(item));
using (HttpClient httpClient = new HttpClient())
{
UpdateItemResponse data = new UpdateItemResponse();
try
{
var authHeader = new AuthenticationHeaderValue("Bearer", await SecureStorage.GetAsync("auth_token"));
httpClient.DefaultRequestHeaders.Authorization = authHeader;
httpClient.BaseAddress = new Uri(Constants.BaseUrl);
StringContent content = new StringContent(requestBody, Encoding.UTF8, "application/json");
HttpResponseMessage result = await httpClient.PostAsync(url, content);
string response = await result.Content.ReadAsStringAsync();
data = JsonConvert.DeserializeObject <UpdateItemResponse>(response);
if (result.IsSuccessStatusCode && result.StatusCode == HttpStatusCode.OK)
{
return(data);
}
return(null);
}
catch (Exception exp)
{
return(null);
}
}
}
public static UpdateItemResponse UpdateItem(AmazonDynamoDBClient dynamoDBClient, UpdateItemRequest requestUpdate)
{
Debug.WriteLine(String.Format("RUNNING SOLUTION CODE: {0}! Follow the steps in the lab guide to replace this method with your own implementation.\n", "UpdateItem"));
UpdateItemResponse response = dynamoDBClient.UpdateItem(requestUpdate);
return(response);
}
public async Task <UpdatePointResult> UpdatePointAsync(UpdatePointRequest updatePointRequest, CancellationToken cancellationToken = default(CancellationToken))
{
if (updatePointRequest == null)
{
throw new ArgumentNullException("updatePointRequest");
}
var geohash = S2Manager.GenerateGeohash(updatePointRequest.GeoPoint);
var hashKey = S2Manager.GenerateHashKey(geohash, _config.HashKeyLength);
var updateItemRequest = updatePointRequest.UpdateItemRequest;
updateItemRequest.TableName = _config.TableName;
var hashKeyValue = new AttributeValue
{
N = hashKey.ToString(CultureInfo.InvariantCulture)
};
updateItemRequest.Key[_config.HashKeyAttributeName] = hashKeyValue;
updateItemRequest.Key[_config.RangeKeyAttributeName] = updatePointRequest.RangeKeyValue;
// Geohash and geoJson cannot be updated.
updateItemRequest.AttributeUpdates.Remove(_config.GeohashAttributeName);
updateItemRequest.AttributeUpdates.Remove(_config.GeoJsonAttributeName);
UpdateItemResponse updateItemResult = await _config.DynamoDBClient.UpdateItemAsync(updateItemRequest, cancellationToken).ConfigureAwait(false);
var updatePointResult = new UpdatePointResult(updateItemResult);
return(updatePointResult);
}
public UpdateItemResponse Handle(UpdateItemRequest request)
{
var response = new UpdateItemResponse();
response.Errors = Validate(request);
if (response.HasErrors)
{
return(response);
}
try
{
var item = _itemRepository.Get(request.Item.Id);
if (item == null)
{
response.Errors.Add(new ErrorStatus("ITEM_NOT_FOUND"));
return(response);
}
UpdateItemObject(item, request.Item);
_itemRepository.Update(item);
return(response);
}
catch (Exception ex)
{
response.Errors.Add(new ErrorStatus("BAD_REQUEST"));
return(response);
}
}
/*--------------------------------------------------------------------------
* UpdatingMovie_async
*--------------------------------------------------------------------------*/
public static async Task <bool> UpdatingMovie_async(UpdateItemRequest updateRequest, bool report)
{
UpdateItemResponse updateResponse = null;
operationSucceeded = false;
operationFailed = false;
if (report)
{
Console.WriteLine(" -- Trying to update a movie item...");
updateRequest.ReturnValues = "ALL_NEW";
}
try
{
updateResponse = await client.UpdateItemAsync(updateRequest);
Console.WriteLine(" -- SUCCEEDED in updating the movie item!");
}
catch (Exception ex)
{
Console.WriteLine(" -- FAILED to update the movie item, because:\n {0}.", ex.Message);
if (updateResponse != null)
{
Console.WriteLine(" -- The status code was " + updateResponse.HttpStatusCode.ToString( ));
}
operationFailed = true; return(false);
}
if (report)
{
Console.WriteLine(" Here is the updated movie informtion:");
Console.WriteLine(movieAttributesToJson(updateResponse.Attributes));
}
operationSucceeded = true;
return(true);
}
public async static Task <UpdateItemResponse> MainUpdateAsync(SongDescription UpdateSong)
{
Dictionary <string, AttributeValue> key = new Dictionary <string, AttributeValue>
{
{ "Artist", new AttributeValue {
S = UpdateSong.Artist
} },
{ "SongTitle", new AttributeValue {
S = UpdateSong.SongTitle
} },
};
Dictionary <string, AttributeValueUpdate> updates = new Dictionary <string, AttributeValueUpdate>();
updates["Duration"] = new AttributeValueUpdate()
{
Action = AttributeAction.PUT,
Value = new AttributeValue {
S = UpdateSong.Duration
}
};
var request = new UpdateItemRequest
{
TableName = tableName,
Key = key,
AttributeUpdates = updates,
ReturnValues = "UPDATED_NEW"
};
UpdateItemResponse r = await client.UpdateItemAsync(request);
return(r);
}
// Not used for now
public async Task <int> IncrementNumberOfSubscribers(string tag, int incrBy)
{
var request = new UpdateItemRequest
{
TableName = TABLENAME,
Key = new Dictionary <string, AttributeValue>()
{
{ "Tag", new AttributeValue {
S = tag
} }
},
ExpressionAttributeNames = new Dictionary <string, string>()
{
{ "#Q", "NumberOfSubscribers" }
},
ExpressionAttributeValues = new Dictionary <string, AttributeValue>()
{
{ ":incr", new AttributeValue {
N = incrBy.ToString()
} }
},
UpdateExpression = "SET #Q = #Q + :incr",
ReturnValues = ReturnValue.UPDATED_NEW,
};
UpdateItemResponse response = await dynamoclient.UpdateItemAsync(request);
return(int.Parse(response.Attributes["NumberOfSubscribers"].N));
}
public static string ConvertToJSON(UpdateItemResponse response)
{
Debug.WriteLine(String.Format("RUNNING SOLUTION CODE: {0}! Follow the steps in the lab guide to replace this method with your own implementation.\n", "ConvertToJSON"));
string json = JsonConvert.SerializeObject(response);
return(json);
}
public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
{
UpdateItemResponse response = new UpdateItemResponse();
context.Read();
int targetDepth = context.CurrentDepth;
while (context.ReadAtDepth(targetDepth))
{
if (context.TestExpression("Attributes", targetDepth))
{
var unmarshaller = new DictionaryUnmarshaller <string, AttributeValue, StringUnmarshaller, AttributeValueUnmarshaller>(StringUnmarshaller.Instance, AttributeValueUnmarshaller.Instance);
response.Attributes = unmarshaller.Unmarshall(context);
continue;
}
if (context.TestExpression("ConsumedCapacity", targetDepth))
{
var unmarshaller = ConsumedCapacityUnmarshaller.Instance;
response.ConsumedCapacity = unmarshaller.Unmarshall(context);
continue;
}
if (context.TestExpression("ItemCollectionMetrics", targetDepth))
{
var unmarshaller = ItemCollectionMetricsUnmarshaller.Instance;
response.ItemCollectionMetrics = unmarshaller.Unmarshall(context);
continue;
}
}
return(response);
}
public UpdatePointResult(UpdateItemResponse updateItemResult)
{
if (updateItemResult == null)
{
throw new ArgumentNullException("updateItemResult");
}
UpdateItemResult = updateItemResult;
}
public async Task TestColsAddAsync()
{
string id = Guid.NewGuid().ToString();
Console.WriteLine(id);
Dictionary <string, AttributeValue> keyItem = new Dictionary <string, AttributeValue>
{
{ "Id", new AttributeValue {
S = id
} }
};
PutItemResponse putResponse = await DDBClient.PutItemAsync(TableName, keyItem);
Assert.AreEqual(putResponse.HttpStatusCode, HttpStatusCode.OK);
Dictionary <string, AttributeValueUpdate> updateItem = new Dictionary <string, AttributeValueUpdate>
{
{ "Col1", new AttributeValueUpdate {
Action = AttributeAction.PUT, Value = new AttributeValue {
N = "0"
}
} }
};
UpdateItemResponse updateResponse = await DDBClient.UpdateItemAsync(TableName, keyItem, updateItem);
Assert.AreEqual(updateResponse.HttpStatusCode, HttpStatusCode.OK);
Dictionary <string, AttributeValueUpdate> updateItem2 = new Dictionary <string, AttributeValueUpdate>
{
{ "Col1", new AttributeValueUpdate {
Action = AttributeAction.PUT, Value = new AttributeValue {
N = "1"
}
} }
};
UpdateItemResponse updateResponse2 = await DDBClient.UpdateItemAsync(TableName, keyItem, updateItem2);
Assert.AreEqual(updateResponse2.HttpStatusCode, HttpStatusCode.OK);
GetItemResponse getItemResponse = await DDBClient.GetItemAsync(TableName, keyItem);
Assert.AreEqual(getItemResponse.HttpStatusCode, HttpStatusCode.OK);
bool isId = getItemResponse.Item.TryGetValue("Id", out AttributeValue id2);
Assert.IsTrue(isId);
Assert.AreEqual(id, id2.S);
bool isCol1 = getItemResponse.Item.TryGetValue("Col1", out AttributeValue co1);
Assert.IsTrue(isCol1);
Assert.AreEqual("1", co1.N);
}
public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
{
UpdateItemResponse response = new UpdateItemResponse();
context.Read();
UnmarshallResult(context, response);
return(response);
}
public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
{
UpdateItemResponse response = new UpdateItemResponse();
context.Read();
response.UpdateItemResult = UpdateItemResultUnmarshaller.GetInstance().Unmarshall(context);
return(response);
}
public UpdateItemResponse GetFakeUpdateItemResponse_UPC_12DigitNumber()
{
var fake = new UpdateItemResponse()
{
Message = $"Record with Id: 1 sucessfully updated."
};
return(fake);
}
static void Main(string[] args)
{
// Get an AmazonDynamoDBClient for the local database
AmazonDynamoDBClient client = GetLocalClient();
if (client == null)
{
PauseForDebugWindow();
return;
}
// Create an UpdateItemRequest to modify two existing nested attributes
// and add a new one
UpdateItemRequest updateRequest = new UpdateItemRequest()
{
TableName = "Movies",
Key = new Dictionary <string, AttributeValue>
{
{ "year", new AttributeValue {
N = "2015"
} },
{ "title", new AttributeValue {
S = "The Big New Movie"
} }
},
ExpressionAttributeValues = new Dictionary <string, AttributeValue>
{
{ ":inc", new AttributeValue {
N = "1"
} }
},
UpdateExpression = "SET info.rating = info.rating + :inc",
ReturnValues = "UPDATED_NEW"
};
// Use AmazonDynamoDBClient.UpdateItem to update the specified attributes
UpdateItemResponse uir = null;
try
{
uir = client.UpdateItem(updateRequest);
}
catch (Exception ex)
{
Console.WriteLine("\nError: UpdateItem failed, because " + ex.Message);
if (uir != null)
{
Console.WriteLine(" Status code was: " + uir.HttpStatusCode.ToString());
}
PauseForDebugWindow();
return;
}
// Get the item from the table and display it to validate that the update succeeded
DisplayMovieItem(client, "2015", "The Big New Movie");
}
private static void UnmarshallResult(JsonUnmarshallerContext context, UpdateItemResponse response)
{
int originalDepth = context.CurrentDepth;
int targetDepth = originalDepth + 1;
while (context.Read())
{
if (context.TestExpression("Attributes", targetDepth))
{
context.Read();
response.Attributes = new Dictionary <String, AttributeValue>();
if (context.CurrentTokenType == JsonToken.Null)
{
continue;
}
KeyValueUnmarshaller <string, AttributeValue, StringUnmarshaller, AttributeValueUnmarshaller> unmarshaller = new KeyValueUnmarshaller <string, AttributeValue, StringUnmarshaller, AttributeValueUnmarshaller>(StringUnmarshaller.GetInstance(), AttributeValueUnmarshaller.GetInstance());
while (context.Read())
{
JsonToken token = context.CurrentTokenType;
if (token == JsonToken.ArrayStart || token == JsonToken.ObjectStart)
{
continue;
}
if (token == JsonToken.ArrayEnd || token == JsonToken.ObjectEnd)
{
break;
}
KeyValuePair <string, AttributeValue> kvp = unmarshaller.Unmarshall(context);
response.Attributes.Add(kvp.Key, kvp.Value);
}
continue;
}
if (context.TestExpression("ConsumedCapacity", targetDepth))
{
context.Read();
response.ConsumedCapacity = ConsumedCapacityUnmarshaller.GetInstance().Unmarshall(context);
continue;
}
if (context.TestExpression("ItemCollectionMetrics", targetDepth))
{
context.Read();
response.ItemCollectionMetrics = ItemCollectionMetricsUnmarshaller.GetInstance().Unmarshall(context);
continue;
}
if (context.CurrentDepth <= originalDepth)
{
return;
}
}
return;
}
/**
* Add a new country or update an existing one.
*/
public static async Task <bool> UpdateCountry(AmazonDynamoDBClient dbClient, string loggedInUserId, Country country)
{
Debug.Untested();
Debug.AssertValid(dbClient);
Debug.AssertID(loggedInUserId);
Debug.Assert(Helper.IsValidCountryCode(country.Code));
Debug.Assert(country.Currencies.Count > 0);
// Check that the system is not locked.
await SystemHelper.CheckSystemNotLocked(dbClient);
// Get the existing country
bool created = false;
Dictionary <string, AttributeValue> key = new Dictionary <string, AttributeValue>();
key.Add(FIELD_COUNTRIES_CODE, new AttributeValue(country.Code));
GetItemResponse getResponse = await dbClient.GetItemAsync(DATASET_COUNTRIES, key);
Debug.AssertValid(getResponse);
Debug.AssertValidOrNull(getResponse.Item);
if (getResponse.Item != null)
{
// The country exists so update it.
Dictionary <string, AttributeValueUpdate> attributeUpdates = new Dictionary <string, AttributeValueUpdate>();
attributeUpdates.Add(FIELD_COUNTRIES_NAME, new AttributeValueUpdate(new AttributeValue(country.Name), AttributeAction.PUT));
attributeUpdates.Add(FIELD_COUNTRIES_CURRENCIES, new AttributeValueUpdate(new AttributeValue(country.Currencies), AttributeAction.PUT));
attributeUpdates.Add(FIELD_COUNTRIES_AVAILABLE, new AttributeValueUpdate(new AttributeValue {
BOOL = country.Available
}, AttributeAction.PUT));
UpdateItemResponse updateResponse = await dbClient.UpdateItemAsync(DATASET_COUNTRIES, key, attributeUpdates);
Debug.AssertValid(updateResponse);
//??++CHECK RESPONSE?
}
else
{
// The country does not exist so create it.
Dictionary <string, AttributeValue> item = new Dictionary <string, AttributeValue>();
item.Add(FIELD_COUNTRIES_CODE, new AttributeValue(country.Code));
item.Add(FIELD_COUNTRIES_NAME, new AttributeValue(country.Name));
item.Add(FIELD_COUNTRIES_CURRENCIES, new AttributeValue(country.Currencies));
item.Add(FIELD_COUNTRIES_AVAILABLE, new AttributeValue {
BOOL = country.Available
});
PutItemResponse putResponse = await dbClient.PutItemAsync(DATASET_COUNTRIES, item);
Debug.AssertValid(putResponse);
//??++CHECK RESPONSE?
created = true;
}
AddCountryAudit(dbClient, loggedInUserId, CountryAuditRecord.AuditChangeType.create, country);
return(created);
}
public async Task <IActionResult> Update([FromBody] Person p)
{
//Define key
Dictionary <string, AttributeValue> key = new Dictionary <string, AttributeValue>
{
{ "Name", new AttributeValue {
S = p.Name
} }
};
// Define attribute updates
Dictionary <string, AttributeValueUpdate> updates = new Dictionary <string, AttributeValueUpdate> ();
updates["IsHome"] = new AttributeValueUpdate
{
Action = AttributeAction.PUT,
Value = new AttributeValue {
BOOL = p.IsHome
}
};
updates["Timestamp"] = new AttributeValueUpdate
{
Action = AttributeAction.PUT,
Value = new AttributeValue
{
S = DateTime.Now.ToString()
}
};
UpdateItemRequest req = new UpdateItemRequest()
{
TableName = TABLE_NAME,
AttributeUpdates = updates,
Key = key
};
//await response from the dynamodb client
UpdateItemResponse resp = await _dynamoClient.UpdateItemAsync(req);
if (resp.HttpStatusCode == System.Net.HttpStatusCode.OK)
{
return(Ok());
}
else
{
return(NotFound());
}
}
public async Task UpdateEmail(string countryId, string name, string id, string newPhoneToInsert, string emailToUpdate)
{
UpdateItemResponse updateItemResponse = await _dynamoDBClient.UpdateItemAsync(new UpdateItemRequest
{
TableName = _tableName,
Key =
{
{ "CountryId", new AttributeValue(countryId) },
{ "Name", new AttributeValue(name) }
},
UpdateExpression = "ADD Phones :newPhone SET Email = :email",
ConditionExpression = "Id = :id",
ExpressionAttributeValues =
{
{
":id", new AttributeValue(id)
},
{
":newPhone", new AttributeValue{
SS = new List <string>{
newPhoneToInsert
}
}
},
{
":email", new AttributeValue(emailToUpdate)
}
}
});
if (updateItemResponse.HttpStatusCode == HttpStatusCode.OK ||
updateItemResponse.HttpStatusCode == HttpStatusCode.Accepted)
{
Console.WriteLine("Fields updated successfully");
}
else
{
Console.WriteLine(updateItemResponse.HttpStatusCode);
}
}
public void UpdateItem(int id)
{
//Update Items
UpdateItemResponse updateClient = null;
if (resultSet.Count > 0)
{
for (int i = 0; i < resultSet.Count; i++)
{
string attributeValue = "";
attributeValue = doc[i]["Id"].AsString();
//var value = resultSet.Where(resultSet[0].Keys.Count>0).Select(x => x.Values);
UpdateItemRequest updateRequest = new UpdateItemRequest()
{
TableName = "Student",
Key = new Dictionary <string, AttributeValue> {
{ "Id", new AttributeValue {
N = attributeValue
} }
},
ExpressionAttributeValues = new Dictionary <string, AttributeValue>
{
{ ":r", new AttributeValue {
N = "10"
} },
{ ":n", new AttributeValue {
N = "1"
} }
},
ConditionExpression = "Marks >= :n",
UpdateExpression = "SET Marks = :r",
ReturnValues = "UPDATED_NEW"
};
updateClient = client.UpdateItem(updateRequest);
}
}
successMessage = updateClient.HttpStatusCode == HttpStatusCode.OK ? "Item Updated " : "Error Occured While Updating";
}
public async Task TestColsLargeAmountsAddAsync()
{
string id = Guid.NewGuid().ToString();
Console.WriteLine(id);
Dictionary <string, AttributeValue> keyItem = new Dictionary <string, AttributeValue>
{
{ "Id", new AttributeValue {
S = id
} }
};
PutItemResponse putResponse = await DDBClient.PutItemAsync(TableName, keyItem);
Assert.AreEqual(putResponse.HttpStatusCode, HttpStatusCode.OK);
int colSize = 500;
Dictionary <string, AttributeValueUpdate> updateItem = new Dictionary <string, AttributeValueUpdate>
{
{ "ColSize", new AttributeValueUpdate {
Action = AttributeAction.PUT, Value = new AttributeValue {
N = $"{colSize}"
}
} }
};
Enumerable.Range(1, colSize).ToList().ForEach(i =>
{
updateItem.Add($"Col{i}", new AttributeValueUpdate {
Action = AttributeAction.PUT, Value = new AttributeValue {
N = "0"
}
});
});
UpdateItemResponse updateResponse = await DDBClient.UpdateItemAsync(TableName, keyItem, updateItem);
Assert.AreEqual(updateResponse.HttpStatusCode, HttpStatusCode.OK);
}
private static void UpdateItemWithLink(string patientId, string reportUrl)
{
Debug.WriteLine("Updating item patientId: {0}, reportURL: {1}", patientId, reportUrl);
UpdateItemRequest requestUpdate = new UpdateItemRequest
{
TableName = InfectionsTableName,
Key = new Dictionary <string, AttributeValue>()
{
{ "PatientID", new AttributeValue {
S = patientId
} }
},
ExpressionAttributeNames = new Dictionary <string, string>()
{
{ "#purl", "PatientReportUrl" },
},
ExpressionAttributeValues = new Dictionary <string, AttributeValue>()
{
{ ":val1", new AttributeValue {
S = reportUrl
} },
},
// This expression does the following:
// Adds a new attribute to the item
UpdateExpression = "SET #purl = :val1"
};
UpdateItemResponse responseUpdate = UpdateItem(requestUpdate);
Debug.WriteLine("Printing item after adding attribute:");
string jsonDisplayText = ConvertToJSON(responseUpdate);
Debug.WriteLine("Display item.");
Debug.WriteLine(jsonDisplayText);
}
private static void UpdateItemWithLink(string customerId, string reportUrl)
{
Debug.WriteLine("Updating item customerId: {0}, reportURL: {1}", customerId, reportUrl);
UpdateItemRequest requestUpdate = new UpdateItemRequest
{
TableName = ReservationsTableName,
Key = new Dictionary <string, AttributeValue>()
{
{ "CustomerID", new AttributeValue {
S = customerId
} }
},
ExpressionAttributeNames = new Dictionary <string, string>()
{
{ "#curl", "CustomerReportUrl" },
},
ExpressionAttributeValues = new Dictionary <string, AttributeValue>()
{
{ ":val1", new AttributeValue {
S = reportUrl
} },
},
// This expression does the following:
// Adds a new attribute to the item
UpdateExpression = "SET #curl = :val1"
};
UpdateItemResponse responseUpdate = UpdateItem(requestUpdate);
Debug.WriteLine("Printing item after adding attribute:");
string jsonDisplayText = JsonConvert.SerializeObject(responseUpdate);
Debug.WriteLine("Display item.");
Debug.WriteLine(jsonDisplayText);
}
public async Task <UpdateItemResponse> Put([FromBody] UpdateItemRequest request, long id = 0)
{
UpdateItemResponse updateItemResponse;
var pattern = @"^(?:\d{12})$";
try
{
if (!Regex.IsMatch(request.UPC, pattern))
{
throw new Exception("UPC must be 12 digit number.");
}
var resp = await _domainService.UpdateItem(id, request);
if (resp)
{
updateItemResponse = new UpdateItemResponse()
{
Message = $"Record with Id: {id} sucessfully updated."
};
}
else
{
updateItemResponse = new UpdateItemResponse()
{
Message = $"Record with Id: {id} does not exist."
};
}
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
return(updateItemResponse);
}
public bool ReleaseLock(LockItem item)
{
if (!item.Owner.Equals(_ownerName))
{
return(false);
}
lock (_threadLock)
{
try
{
_locks.TryRemove(item.UniqueIdentifier, out var removedLockItem);
Dictionary <string, AttributeValue> expressionAttributeValues =
new Dictionary <string, AttributeValue>
{
{ RvnValueExpressionVariable, new AttributeValue {
S = item.RecordVersionNumber
} },
{ OwnerNameValueExpressionVariable, new AttributeValue {
S = item.Owner
} }
};
Dictionary <string, string> expressionAttributeNames = new Dictionary <string, string>
{
{ PkPathExpressionVariable, _partitionKeyName },
{ OwnerNamePathExpressionVariable, OwnerName },
{ RvnPathExpressionVariable, RecordVersionNumber }
};
var conditionalExpression = PkExistsAndOwnerNameSameAndRvnSameCondition;
Dictionary <string, AttributeValue> key = new Dictionary <string, AttributeValue>
{
{
_partitionKeyName, new AttributeValue
{
S = item.UniqueIdentifier
}
}
};
string updateExpression = null;
expressionAttributeNames.Add(IsReleasedPathExpressionVariable, IsReleased);
expressionAttributeValues.Add(IsReleasedValueExpressionVariable, IsReleasedAttributeValue);
updateExpression = UpdateIsReleased;
UpdateItemRequest updateItemRequest =
new UpdateItemRequest(_tableName, key, null)
{
ConditionExpression = conditionalExpression,
UpdateExpression = updateExpression,
ExpressionAttributeNames = expressionAttributeNames,
ExpressionAttributeValues = expressionAttributeValues
};
UpdateItemResponse response =
_client.UpdateItemAsync(updateItemRequest, CancellationToken.None).Result;
}
catch (ConditionalCheckFailedException conditionalCheckFailedException)
{
// logger.debug("Someone else acquired the lock before you asked to release it", conditionalCheckFailedException);
return(false);
}
catch (AmazonClientException amazonClientException)
{
throw;
}
}
return(true);
}
/**
* Retrieve the item from the UpdateItemOutcome object and print
* its contents in JSON format
*
* @param response Order
* @return Order in JSON format
*/
private static string ConvertToJSON(UpdateItemResponse response)
{
// STUDENT TODO 6: Replace the solution with your own code
return(Solution.ConvertToJSON(response));
}
public async Task <Response <PlanoTreino> > SalvarAsync(PlanoTreino planoTreino)
{
var resp = new Response <PlanoTreino>();
if (planoTreino == null)
{
resp.ErrorMessages.Add("Grupo Muscular inválido.");
return(resp);
}
if (planoTreino.UsuarioId == 0)
{
resp.ErrorMessages.Add("Usuario não informado");
return(resp);
}
string gruposMuscularesJson = "";
try
{
using (MemoryStream ms = new MemoryStream())
{
DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(List <GrupoMuscular>));
ser.WriteObject(ms, planoTreino.GruposMusculares);
byte[] json = ms.ToArray();
ms.Close();
gruposMuscularesJson = Encoding.UTF8.GetString(json, 0, json.Length);
}
}
catch (Exception e)
{
_log.LogError(e.Message);
resp.ErrorMessages.Add(e.Message);
}
resp.Return = planoTreino;
var attributeValues = new Dictionary <string, AttributeValue>();
var attributeNames = new Dictionary <string, string>();
string updExpr = String.Empty;
planoTreino.DtAtualizacao = DateTime.Now;
attributeNames.Add("#dtAt", "dt-atualizacao");
attributeValues.Add(":dtAt", new AttributeValue {
S = planoTreino.DtAtualizacao.ToString()
});
updExpr = "#dtAt = :dtAt";
if (planoTreino.Id < 1)
{
planoTreino.Id = (Int32)DateTimeOffset.UtcNow.ToUnixTimeSeconds();
attributeNames.Add("#usrId", "usuario-id");
attributeValues.Add(":usrId", new AttributeValue {
N = planoTreino.UsuarioId.ToString()
});
updExpr += ", #usrId = :usrId";
}
if (!String.IsNullOrEmpty(planoTreino.Descricao))
{
attributeNames.Add("#descr", "descricao");
attributeValues.Add(":descr", new AttributeValue {
S = planoTreino.Descricao
});
updExpr += ", #descr = :descr";
}
if (!String.IsNullOrEmpty(planoTreino.Observacao))
{
attributeNames.Add("#obs", "observacao");
attributeValues.Add(":obs", new AttributeValue {
S = planoTreino.Observacao
});
updExpr += ", #obs = :obs";
}
if (!String.IsNullOrEmpty(gruposMuscularesJson))
{
attributeNames.Add("#grp", "grupos-musculares");
attributeValues.Add(":grp", new AttributeValue {
S = gruposMuscularesJson
});
updExpr += ", #grp = :grp";
}
var request = new UpdateItemRequest
{
TableName = _context.TableName,
Key = new Dictionary <string, AttributeValue>
{
{ "tipo", new AttributeValue {
S = TipoPlanoTreino(planoTreino)
} },
{ "id", new AttributeValue {
N = planoTreino.Id.ToString()
} }
},
ExpressionAttributeNames = attributeNames,
ExpressionAttributeValues = attributeValues,
UpdateExpression = "SET " + updExpr
};
UpdateItemResponse updResponse = null;
using (var client = _context.GetClientInstance())
{
try
{
updResponse = await client.UpdateItemAsync(request);
resp.Messages.Add(updResponse.HttpStatusCode.ToString());
}
catch (Exception e)
{
_log.LogError(e.Message);
resp.ErrorMessages.Add(e.Message);
}
return(resp);
}
}
public async Task <Response <PostagemHome> > SalvarAsync(PostagemHome postagemHome)
{
var resp = new Response <PostagemHome>();
if (postagemHome == null)
{
resp.ErrorMessages.Add("postagem nula.");
return(resp);
}
if (postagemHome.UsuarioId == 0)
{
resp.ErrorMessages.Add("Usuario não informado");
return(resp);
}
resp.Return = postagemHome;
var attributeValues = new Dictionary <string, AttributeValue>();
var attributeNames = new Dictionary <string, string>();
string updExpr = String.Empty;
postagemHome.DataAtualizacao = DateTime.Now;
attributeNames.Add("#dtAt", "dt-atualizacao");
attributeValues.Add(":dtAt", new AttributeValue {
S = postagemHome.DataAtualizacao.ToString("dd/MM/yyyy hh:mm:ss")
});
updExpr = "#dtAt = :dtAt";
attributeNames.Add("#ordem", "ordem");
attributeValues.Add(":ordem", new AttributeValue {
N = postagemHome.Ordem.ToString()
});
updExpr += ", #ordem = :ordem";
if (postagemHome.Id < 1)
{
postagemHome.Id = (Int32)DateTimeOffset.UtcNow.ToUnixTimeSeconds();
attributeNames.Add("#usrId", "usuario-id");
attributeValues.Add(":usrId", new AttributeValue {
N = postagemHome.UsuarioId.ToString()
});
updExpr += ", #usrId = :usrId";
}
if (!String.IsNullOrEmpty(postagemHome.Titulo))
{
attributeNames.Add("#titulo", "titulo");
attributeValues.Add(":titulo", new AttributeValue {
S = postagemHome.Titulo
});
updExpr += ", #titulo = :titulo";
}
if (!String.IsNullOrEmpty(postagemHome.Texto))
{
attributeNames.Add("#texto", "texto");
attributeValues.Add(":texto", new AttributeValue {
S = postagemHome.Texto
});
updExpr += ", #texto = :texto";
}
attributeNames.Add("#urlImagem", "url-imagem");
if (!String.IsNullOrEmpty(postagemHome.UrlImagem))
{
attributeValues.Add(":urlImagem", new AttributeValue {
S = postagemHome.UrlImagem
});
updExpr += ", #urlImagem = :urlImagem";
}
else
{
updExpr += " REMOVE #urlImagem";
}
var request = new UpdateItemRequest
{
TableName = _context.TableName,
Key = new Dictionary <string, AttributeValue>
{
{ "tipo", new AttributeValue {
S = _type
} },
{ "id", new AttributeValue {
N = postagemHome.Id.ToString()
} }
},
ExpressionAttributeNames = attributeNames,
ExpressionAttributeValues = attributeValues,
UpdateExpression = "SET " + updExpr
};
UpdateItemResponse updResponse = null;
using (var client = _context.GetClientInstance())
{
try
{
updResponse = await client.UpdateItemAsync(request);
resp.Messages.Add(updResponse.HttpStatusCode.ToString());
}
catch (Exception e)
{
_log.LogError(e.Message);
resp.ErrorMessages.Add(e.Message);
}
return(resp);
}
}
public void SendHeartbeat(LockItem item)
{
long leaseDurationToEnsureInMilliseconds = _leaseDuration;
if (item.IsExpired || !item.Owner.Equals(this._ownerName) || item.IsReleased)
{
_locks.TryRemove(item.UniqueIdentifier, out var removedLockItem);
throw new LockNotGrantedException("Cannot send heartbeat because lock is not granted", null);
}
lock (_threadLock)
{
string recordVersionNumber = GenerateRecordVersionNumber();
string conditionalExpression = null;
string updateExpression = null;
Dictionary <string, AttributeValue> expressionAttributeValues = new Dictionary <string, AttributeValue>
{
{ RvnValueExpressionVariable, new AttributeValue {
S = item.RecordVersionNumber
} },
{ OwnerNameValueExpressionVariable, new AttributeValue {
S = item.Owner
} }
};
Dictionary <string, string> expressionAttributeNames = new Dictionary <string, string>
{
{ PkPathExpressionVariable, _partitionKeyName },
{ LeaseDurationPathValueExpressionVariable, LeaseDuration },
{ RvnPathExpressionVariable, RecordVersionNumber },
{ OwnerNamePathExpressionVariable, OwnerName }
};
expressionAttributeValues.Add(NewRvnValueExpressionVariable, new AttributeValue {
S = recordVersionNumber
});
expressionAttributeValues.Add(LeaseDurationValueExpressionVariable, new AttributeValue
{
S = _leaseDuration.ToString()
});
conditionalExpression = PkExistsAndOwnerNameSameAndRvnSameCondition;
updateExpression = UpdateLeaseDurationAndRvn;
var key = new Dictionary <string, AttributeValue>
{
{ _partitionKeyName, new AttributeValue {
S = item.UniqueIdentifier
} }
};
UpdateItemRequest updateItemRequest =
new UpdateItemRequest(_tableName, key, null)
{
ConditionExpression = conditionalExpression,
UpdateExpression = updateExpression,
ExpressionAttributeValues = expressionAttributeValues,
ExpressionAttributeNames = expressionAttributeNames
};
try
{
UpdateItemResponse response = _client.UpdateItemAsync(updateItemRequest).Result;
if (response.HttpStatusCode != HttpStatusCode.OK)
{
throw new LockNotGrantedException("failed to updated database", null);
}
item.UpdatedRecordVersionNumber(recordVersionNumber, DateTime.Now,
leaseDurationToEnsureInMilliseconds);
Console.WriteLine($"updated lock item : {item.UniqueIdentifier} with new RVN: {recordVersionNumber} and lease {_leaseDuration / 1000} seconds");
}
catch (ConditionalCheckFailedException conditionalCheckFailedException)
{
// logger.debug("Someone else acquired the lock, so we will stop heartbeating it", conditionalCheckFailedException);
_locks.TryRemove(item.UniqueIdentifier, out var lockToRemove);
throw new LockNotGrantedException("Someone else acquired the lock, so we will stop heartbeating it",
conditionalCheckFailedException);
}
}
}
public async Task <string> FunctionHandler(S3Event evnt, ILambdaContext context)
{
var s3Event = evnt.Records?[0].S3;
if (s3Event == null)
{
return(null);
}
else
{
try
{
S3Client = new AmazonS3Client(bucketRegion);
GetObjectRequest request = new GetObjectRequest
{
BucketName = s3Event.Bucket.Name,
Key = s3Event.Object.Key
};
int count = 0;
int recordsUpdated = 0;
int recordsErrored = 0;
using (GetObjectResponse response = await S3Client.GetObjectAsync(request))
{
StreamReader reader;
using (reader = new StreamReader(response.ResponseStream, Encoding.UTF8))
{
using (var csv = new CsvReader(reader))
{
csv.Read();
csv.ReadHeader();
while (csv.Read())
{
if (count < 2000)
{
//Console.WriteLine("INFO : Week : '{0}' Day : '{1}' UPRN : '{2}'", csv.GetField<String>("Week"), csv.GetField<String>("Day"), csv.GetField<String>("UPRN"));
String round = "";
switch (csv.GetField <String>("Week"))
{
case "A":
switch (csv.GetField <String>("Day"))
{
case "Monday":
round = "1";
break;
case "Tuesday":
round = "2";
break;
case "Wednesday":
round = "3";
break;
case "Thursday":
round = "4";
break;
case "Friday":
round = "5";
break;
default:
Console.WriteLine("Unexpected Day found for UPRN : '{0}'", csv.GetField <String>("UPRN"));
break;
}
break;
case "B":
switch (csv.GetField <String>("Day"))
{
case "Monday":
round = "7";
break;
case "Tuesday":
round = "8";
break;
case "Wednesday":
round = "9";
break;
case "Thursday":
round = "10";
break;
case "Friday":
round = "11";
break;
default:
Console.WriteLine("Unexpected Day found for UPRN : '{0}'", csv.GetField <String>("UPRN"));
break;
}
break;
default:
Console.WriteLine("Unexpected Week found for UPRN : '{0}'", csv.GetField <String>("UPRN"));
break;
}
AmazonDynamoDBClient client = new AmazonDynamoDBClient();
string tableName = "bin-details";
var dynamoRequest = new UpdateItemRequest
{
TableName = tableName,
Key = new Dictionary <string, AttributeValue>()
{
{ "UPRN", new AttributeValue {
N = csv.GetField <String>("UPRN")
} }
},
ExpressionAttributeNames = new Dictionary <string, string>()
{
{ "#D", "Day" },
{ "#R", "Round" },
{ "#B", "Bins2Sacks" }
},
ExpressionAttributeValues = new Dictionary <string, AttributeValue>()
{
{ ":day", new AttributeValue {
S = csv.GetField <String>("Day")
} },
{ ":round", new AttributeValue {
N = round
} },
{ ":bins2sacks", new AttributeValue {
S = "Y"
} }
},
UpdateExpression = "SET #D = :day, #R = :round, #B = :bins2sacks"
};
UpdateItemResponse dynamoResponse = await client.UpdateItemAsync(dynamoRequest);
if (dynamoResponse.HttpStatusCode == HttpStatusCode.OK)
{
recordsUpdated++;
}
else
{
Console.WriteLine("DynamoResponse NOT OK : '{0}'", dynamoResponse.HttpStatusCode);
recordsErrored++;
}
}
count++;
}
}
}
}
Console.WriteLine("Records processed : '{0}'", count);
Console.WriteLine("Records updated : '{0}'", recordsUpdated);
Console.WriteLine("Records not updated : '{0}'", recordsErrored);
return("{\"Message\":\"Found file\",\"lambdaResult\":\"Success\"}");
}
catch (AmazonS3Exception error)
{
Console.WriteLine("ERROR : Reading Email : '{0}' when reading file", error.Message);
return(null);
}
catch (Exception error)
{
Console.WriteLine("ERROR : An Unknown encountered : {0}' when reading file", error.Message);
return(null);
}
}
}
