public static async void UpdateBookPriceConditionally(AmazonDynamoDBClient client, Table productCatalog)
        {
            Console.WriteLine("\n*** Executing UpdateBookPriceConditionally() ***");

            int partitionKey = SampleBookId;

            var book = new Document();

            book["Id"]    = partitionKey;
            book["Price"] = 29.99;

            // For conditional price update, creating a condition expression.
            Expression expr = new Expression();

            expr.ExpressionStatement = "Price = :val";
            expr.ExpressionAttributeValues[":val"] = 19.00;

            // Optional parameters.
            UpdateItemOperationConfig config = new UpdateItemOperationConfig
            {
                ConditionalExpression = expr,
                ReturnValues          = ReturnValues.AllNewAttributes
            };
            Document updatedBook = await productCatalog.UpdateItemAsync(book, config);

            Console.WriteLine("UpdateBookPriceConditionally: Printing item whose price was conditionally updated");
            PrintDocument(client, updatedBook);
        }
        public void ConditionalUpdate <T>(T tObject, string condAttribute, object expectedValue)
        {
            var splittedAttributes = condAttribute.Split('.');

            var    specificAttributeToCheck = condAttribute;
            string first = "";
            string last  = condAttribute;

            if (splittedAttributes.Length > 1)
            {
                last  = splittedAttributes.Last();
                first = condAttribute.Remove(condAttribute.Length - last.Length);
            }

            Expression expr = new Expression();

            expr.ExpressionStatement = first + "#Cond = :Cond";
            expr.ExpressionAttributeNames["#Cond"] = last;
            if (expectedValue.GetType() == typeof(int))
            {
                expr.ExpressionAttributeValues[":Cond"] = (int)expectedValue;
            }
            if (expectedValue.GetType() == typeof(string))
            {
                expr.ExpressionAttributeValues[":Cond"] = (string)expectedValue;
            }

            UpdateItemOperationConfig config = new UpdateItemOperationConfig()
            {
                ConditionalExpression = expr,
                ReturnValues          = ReturnValues.AllNewAttributes
            };

            dynamoDBTable.UpdateItem(AWSDocumentConverter.ToDocument(tObject), config);
        }
        /// <summary>
        /// Updates a book item if it meets the specified criteria.
        /// </summary>
        /// <param name="productCatalog">A DynamoDB table object.</param>
        /// <param name="sampleBookId">An integer value representing the book's ID.</param>
        public static async void UpdateBookPriceConditionally(
            Table productCatalog,
            int sampleBookId)
        {
            Console.WriteLine("\n*** Executing UpdateBookPriceConditionally() ***");

            int partitionKey = sampleBookId;

            var book = new Document
            {
                ["Id"]    = partitionKey,
                ["Price"] = 29.99,
            };

            // For conditional price update, creating a condition expression.
            var expr = new Expression
            {
                ExpressionStatement = "Price = :val",
            };

            expr.ExpressionAttributeValues[":val"] = 19.00;

            // Optional parameters.
            var config = new UpdateItemOperationConfig
            {
                ConditionalExpression = expr,
                ReturnValues          = ReturnValues.AllNewAttributes,
            };

            Document updatedBook = await productCatalog.UpdateItemAsync(book, config);

            Console.WriteLine("UpdateBookPriceConditionally: Printing item whose price was conditionally updated");
            PrintDocument(updatedBook);
        }
Exemple #4
0
        public async Task <APIGatewayProxyResponse> Update(APIGatewayProxyRequest request, ILambdaContext context)
        {
            var appointmentRequest = JsonConvert.DeserializeObject <AppointmentRequest>(request.Body);
            var client             = new AmazonDynamoDBClient(RegionEndpoint.USEast1);

            var appointmentId  = appointmentRequest.AppointmentId;
            var productCatalog = Table.LoadTable(client, "Appointment");

            var appointment = new Document
            {
                ["AppointmentId"] = appointmentId,
                ["PracticeId"]    = appointmentRequest.PracticeId,
                ["IsServed"]      = "true"
            };

            var config = new UpdateItemOperationConfig
            {
                // Get updated item in response.
                ReturnValues = ReturnValues.AllNewAttributes
            };
            await productCatalog.UpdateItemAsync(appointment, config);

            return(new APIGatewayProxyResponse
            {
                StatusCode = (int)HttpStatusCode.OK,
                Body = "success"
            });
        }
        private UpdateItemOperationConfig GetUpdateItemOperationConfigForConditionalUpdate(string condAttribute, object expectedValue)
        {
            var splittedAttributes = condAttribute.Split('.');

            var    specificAttributeToCheck = condAttribute;
            string first = "";
            string last  = condAttribute;

            if (splittedAttributes.Length > 1)
            {
                last  = splittedAttributes.Last();
                first = condAttribute.Remove(condAttribute.Length - last.Length);
            }

            Expression expr = new Expression();

            expr.ExpressionStatement = first + "#Cond = :Cond";
            expr.ExpressionAttributeNames["#Cond"] = last;
            if (expectedValue.GetType() == typeof(int))
            {
                expr.ExpressionAttributeValues[":Cond"] = (int)expectedValue;
            }
            if (expectedValue.GetType() == typeof(string))
            {
                expr.ExpressionAttributeValues[":Cond"] = (string)expectedValue;
            }

            UpdateItemOperationConfig config = new UpdateItemOperationConfig()
            {
                ConditionalExpression = expr,
                ReturnValues          = ReturnValues.None
            };

            return(config);
        }
        /// <summary>
        /// Updates multiple attributes for a book and writes the changes to the
        /// DynamoDB table ProductCatalog.
        /// </summary>
        /// <param name="productCatalog">A DynamoDB table object.</param>
        /// <param name="sampleBookId">An integer value representing the book's ID.</param>
        public static async void UpdateMultipleAttributes(
            Table productCatalog,
            int sampleBookId)
        {
            Console.WriteLine("\nUpdating multiple attributes....");
            int partitionKey = sampleBookId;

            var book = new Document
            {
                ["Id"] = partitionKey,

                // List of attribute updates.
                // The following replaces the existing authors list.
                ["Authors"] = new List <string> {
                    "Author x", "Author y"
                },
                ["newAttribute"] = "New Value",
                ["ISBN"]         = null, // Remove it.
            };

            // Optional parameters.
            var config = new UpdateItemOperationConfig
            {
                // Gets updated item in response.
                ReturnValues = ReturnValues.AllNewAttributes,
            };

            Document updatedBook = await productCatalog.UpdateItemAsync(book, config);

            Console.WriteLine("UpdateMultipleAttributes: Printing item after updates ...");
            PrintDocument(updatedBook);
        }
        public async Task <ActionResult <string> > Put(int year, string title)
        {
            Table table = Table.LoadTable(dynamoDb, TableName);

            var movie = new Document();

            movie["year"]  = year;
            movie["title"] = title;

            var movieInfo = new Document();

            movieInfo["rating"] = 1;

            // if you had a more nested structure,
            // how would you only update a single item in the nested object?
            movie["info"] = movieInfo;

            // Optional parameters.
            UpdateItemOperationConfig config = new UpdateItemOperationConfig
            {
                // Get updated item in response.
                ReturnValues = ReturnValues.AllNewAttributes
            };

            var document = await table.UpdateItemAsync(movie, config);

            return(document.ToJsonPretty());
        }
Exemple #8
0
        private void SaveHelper <T>(T value, DynamoDBOperationConfig operationConfig)
        {
            if (value == null)
            {
                return;
            }

            DynamoDBFlatConfig flatConfig = new DynamoDBFlatConfig(operationConfig, this.Config);
            ItemStorage        storage    = ObjectToItemStorage(value, false, flatConfig);

            if (storage == null)
            {
                return;
            }

            Table table = GetTargetTable(storage.Config, flatConfig);

            if ((flatConfig.SkipVersionCheck.HasValue && flatConfig.SkipVersionCheck.Value) || !storage.Config.HasVersion)
            {
                table.UpdateHelper(storage.Document, table.MakeKey(storage.Document), null);
            }
            else
            {
                Document expectedDocument = CreateExpectedDocumentForVersion(storage);
                SetNewVersion(storage);
                var updateItemOperationConfig = new UpdateItemOperationConfig
                {
                    Expected     = expectedDocument,
                    ReturnValues = ReturnValues.None,
                };
                table.UpdateHelper(storage.Document, table.MakeKey(storage.Document), updateItemOperationConfig);
                PopulateInstance(storage, value, flatConfig);
            }
        }
        public static async void UpdateMultipleAttributes(AmazonDynamoDBClient client, Table productCatalog)
        {
            Console.WriteLine("\n*** Executing UpdateMultipleAttributes() ***");
            Console.WriteLine("\nUpdating multiple attributes....");
            int partitionKey = SampleBookId;

            var book = new Document();

            book["Id"] = partitionKey;
            // List of attribute updates.
            // The following replaces the existing authors list.
            book["Authors"] = new List <string> {
                "Author x", "Author y"
            };
            book["newAttribute"] = "New Value";
            book["ISBN"]         = null; // Remove it.

            // Optional parameters.
            UpdateItemOperationConfig config = new UpdateItemOperationConfig
            {
                // Get updated item in response.
                ReturnValues = ReturnValues.AllNewAttributes
            };
            Document updatedBook = await productCatalog.UpdateItemAsync(book, config);

            Console.WriteLine("UpdateMultipleAttributes: Printing item after updates ...");
            PrintDocument(client, updatedBook);
        }
        public async Task <Document> UpdateItemAsync(DynamoDbTablesEnum dynamoDbTable,
                                                     Document document,
                                                     UpdateItemOperationConfig config)
        {
            Table table = this.LoadTable(dynamoDbTable);

            return(await table.UpdateItemAsync(document, config));
        }
        public Document PartialUpdateCommand <T>(T tObject, ReturnValues returnValues = ReturnValues.AllNewAttributes)
        {
            var document = AWSDocumentConverter.ToDocument(tObject);

            UpdateItemOperationConfig config = new UpdateItemOperationConfig
            {
                ReturnValues = returnValues
            };

            return(dynamoDBTable.UpdateItem(document, config));
        }
Exemple #12
0
        private static void UpdateRecommendation(Document updatedDocument)
        {
            // Optional parameters.
            UpdateItemOperationConfig config = new UpdateItemOperationConfig
            {
                // Get updated item in response.
                ReturnValues = ReturnValues.None,
            };

            _recommendationsTable.UpdateItemAsync(updatedDocument, config);
        }
        public async Task UpdateItem(string tableName, JArray item)
        {
            var      tableRepo = new TableRepo(dynamoDB);
            Document tableAttr = await tableRepo.GetTableAttr(tableName);

            List <string> attribute = new List <string> {
            };
            List <string> type      = new List <string> {
            };
            List <string> key       = new List <string> {
            };

            if (tableAttr != null)
            {
                var c = tableAttr["attr"].AsDocument().GetAttributeNames();
                foreach (var c1 in c)
                {
                    attribute.Add(c1);
                    var t = tableAttr["attr"].AsDocument()[c1].AsDocument()["type"];
                    var k = tableAttr["attr"].AsDocument()[c1].AsDocument()["key"];
                    type.Add(t);
                    key.Add(k);
                }
            }

            Table table = Table.LoadTable(dynamoDB, tableName);
            var   itm   = new Document();

            foreach (var value in item)
            {
                switch (type[attribute.IndexOf(value["key"].ToString())])
                {
                case "N":
                    itm[value["key"].ToString()] = (float)value["value"];
                    break;

                case "B":
                    byte[]       byteArray = Encoding.ASCII.GetBytes(value["value"].ToString());
                    MemoryStream stream    = new MemoryStream(byteArray);
                    itm[value["key"].ToString()] = stream;
                    break;

                default:
                    itm[value["key"].ToString()] = value["value"].ToString();
                    break;
                }
            }
            UpdateItemOperationConfig config = new UpdateItemOperationConfig
            {
                ReturnValues = ReturnValues.AllNewAttributes
            };
            await table.UpdateItemAsync(itm, config);
        }
        public async Task <User> UpdateUserAsync(User userToUpdate)
        {
            var userDocument = ConvertUserToDocument(userToUpdate);
            var config       = new UpdateItemOperationConfig
            {
                ReturnValues = ReturnValues.AllNewAttributes
            };

            var result = await UserTable.UpdateItemAsync(userDocument, config);

            return(ConvertDocumentToUser(result));
        }
        private async Task TestExpressionUpdate(Table hashTable)
        {
            Document doc = new Document();

            doc["Id"]   = DateTime.Now.Ticks;
            doc["name"] = "condition-form";
            await hashTable.PutItemAsync(doc);

            Expression expression = new Expression
            {
                ExpressionStatement       = "attribute_not_exists(referencecounter) or referencecounter = :cond1",
                ExpressionAttributeValues = new Dictionary <string, DynamoDBEntry>
                {
                    { ":cond1", 0 }
                }
            };
            UpdateItemOperationConfig config = new UpdateItemOperationConfig
            {
                ConditionalExpression = expression
            };

            doc["update-test"] = 1;
            //Assert.IsTrue(hashTable.TryUpdateItem(doc, config));
            await hashTable.UpdateItemAsync(doc, config);

            doc["referencecounter"] = 0;
            await hashTable.UpdateItemAsync(doc);

            doc["update-test"] = null;
            //Assert.IsTrue(hashTable.TryUpdateItem(doc, config));
            await hashTable.UpdateItemAsync(doc, config);

            // Make sure removing attributes works
            doc = await hashTable.GetItemAsync(doc);

            Assert.IsFalse(doc.Contains("update-test"));

            doc["referencecounter"] = 1;
            await hashTable.UpdateItemAsync(doc);

            doc["update-test"] = 3;
            //Assert.IsFalse(hashTable.TryUpdateItem(doc, config));
            await AssertExtensions.ExpectExceptionAsync(hashTable.UpdateItemAsync(doc, config));

            doc = await hashTable.GetItemAsync(doc);

            Assert.IsFalse(doc.Contains("update-test"));

            await hashTable.DeleteItemAsync(doc);
        }
Exemple #16
0
        public async Task UpdateItemAsync(string tableName, object item)
        {
            var   jsonData = JsonConvert.SerializeObject(item, serializerSettings);
            var   document = Document.FromJson(jsonData);
            Table table;

            try
            {
                table = Table.LoadTable(dynamoDBClient, tableName);
            }
            catch (ResourceNotFoundException e)
            {
                throw new TableNameFailException($"Not found the source '{tableName}'.", e);
            }

            foreach (var k in table.Keys)
            {
                if (!document.ContainsKey(k.Key))
                {
                    throw new PrimaryKeyNameFailException($"Not found the primary key '{k.Key}' in saving data.", null);
                }
            }

            var keys = table.Keys.Select(k => k.Key).ToArray();

            var config = new UpdateItemOperationConfig
            {
                ConditionalExpression = new Expression
                {
                    ExpressionStatement = string.Join(" && ", keys.Select(k => $"attribute_exists({k})"))
                },
                ReturnValues = ReturnValues.None
            };

            try
            {
                await table.UpdateItemAsync(document, config);
            }
            catch (ConditionalCheckFailedException e)
            {
                throw new NotExistKeyException(
                          $"The source '{tableName}' has not contained data with keys '{string.Join(", ", keys)}'.",
                          e);
            }
        }
Exemple #17
0
        private async Task <bool> UpdateTable <T>(Table table, T item, Expression condtionalExpression)
        {
            var document = _ddbContext.ToDocument(item);
            var config   = new UpdateItemOperationConfig {
                ConditionalExpression = condtionalExpression
            };

            try
            {
                await table.UpdateItemAsync(document, config);

                return(true);
            }
            catch (ConditionalCheckFailedException)
            {
                return(false);
            }
        }
Exemple #18
0
    private void UpdateMultipleAttributes()
    {
        this.displayMessage += ("\n*** Executing UpdateMultipleAttributes() ***");
        this.displayMessage += ("\nUpdating multiple attributes....");
        int hashKey = sampleBookId;

        var book = new Document();

        book["Id"] = hashKey;
        // List of attribute updates.
        // The following replaces the existing authors list.
        book["Authors"] = new List <string> {
            "Author x", "Author y"
        };
        book["newAttribute"] = "New Value";
        book["ISBN"]         = null; // Remove it.

        // Optional parameters.
        UpdateItemOperationConfig config = new UpdateItemOperationConfig
        {
            // Get updated item in response.
            ReturnValues = ReturnValues.AllNewAttributes
        };

        productCatalog.UpdateItemAsync(book, config,
                                       (AmazonDynamoResult <Document> result) =>
        {
            if (result.Exception != null)
            {
                this.displayMessage += ("\nUpdateMultipleAttributes ; " + result.Exception.Message);
                Debug.LogException(result.Exception);
                return;
            }
            Document updatedBook = result.Response;
            this.displayMessage += ("\nUpdateMultipleAttributes: Printing item after updates ...");
            PrintDocument(updatedBook);
        }, null);
    }
Exemple #19
0
        public async Task <IActionResult> Gete([FromHeader] string key, [FromHeader] string payload)
        {
            try
            {
                long timestamp = (long)DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1)).TotalMilliseconds;

                if (key != "enginekey")
                {
                    return(BadRequest("bad"));
                }
                Console.WriteLine(payload);
                AmazonDynamoDBClient client = new AmazonDynamoDBClient();
                Table           table       = Table.LoadTable(client, "OrderRegistry");
                List <Document> docs        = new List <Document>();

                // begin parse payload
                int i = 0;
                if (payload[i] != '[')
                {
                    throw new Exception();
                }
                Document doc, docother = new Document();
                string   Id = new string(""); string Quantity = new string(""); string Price = new string(""); string Executed = new string(""); string OtherOrder = new string("");
                i += 1;
                while (true && i < payload.Length)
                {
                    if (payload[i] == ',')
                    {
                        i += 1; break;
                    }
                    Id += payload[i];
                    i  += 1;
                }
                while (true && i < payload.Length)
                {
                    if (payload[i] == ',')
                    {
                        i += 1; break;
                    }
                    Quantity += payload[i];
                    i        += 1;
                }
                while (true && i < payload.Length)
                {
                    if (payload[i] == ',')
                    {
                        i += 1; break;
                    }
                    Price += payload[i];
                    i     += 1;
                }
                while (true && i < payload.Length)
                {
                    if (payload[i] == ',')
                    {
                        i += 1; break;
                    }
                    Executed += payload[i];
                    i        += 1;
                }
                while (true && i < payload.Length)
                {
                    if (payload[i] == ']')
                    {
                        break;
                    }
                    OtherOrder += payload[i];
                    i          += 1;
                }
                double executed;
                try { executed = double.Parse(Executed); } catch { return(BadRequest("error parse")); }
                // end parse payload

                doc = await table.GetItemAsync(Id);

                docother = await table.GetItemAsync(OtherOrder);

                if (doc["Email"].ToString() == docother["Email"].ToString()) // self fill
                {
                    if (doc["OrderType"].ToString() == "limit")
                    {
                        double currentself = doc["OrderQuantity"].AsDouble();

                        currentself = currentself - executed;
                        Document currentselfdoc = new Document();
                        currentselfdoc["Id"]            = Id.ToString();
                        currentselfdoc["OrderQuantity"] = currentself.ToString();
                        await table.UpdateItemAsync(currentselfdoc);

                        return(Ok());
                    }
                    return(Ok());
                }

                doc["Price"] = Price;

                if (doc["OrderType"].ToString() == "market") // recent orders
                {
                    Document recentorder = new Document();
                    recentorder["Timestamp"] = timestamp.ToString();
                    recentorder["Price"]     = Price.ToString();
                    recentorder["Quantity"]  = Executed.ToString();
                    Table recentordertable = Table.LoadTable(client, "RecentOrdersSPXUSD");
                    await recentordertable.PutItemAsync(recentorder);
                }

                double price; double.TryParse(Price, out price);
                await table.UpdateItemAsync(doc);

                Table    postable = Table.LoadTable(client, "PositionRegistry");
                Document posdoc   = await postable.GetItemAsync(doc["Email"].ToString());

                Document posupdate = new Document();
                double   pos;
                try
                {
                    posdoc["POSSPXUSD"].ToString();
                    if (posdoc["POSSPXUSD"].ToString() == "0")
                    {
                        pos = 0;
                    }
                    pos = posdoc["POSSPXUSD"].AsDouble();
                }
                catch //never position or 0 position
                {
                    await postable.PutItemAsync(new Document()
                    {
                        ["Email"] = doc["Email"].ToString()
                    });

                    pos = 0;
                }


                if (doc["Side"].ToString() == "buy" && doc["OrderType"].ToString() == "limit")
                {
                    pos = pos + executed;
                }
                else if (doc["Side"].ToString() == "sell" && doc["OrderType"].ToString() == "limit")
                {
                    pos       = pos - executed;
                    executed *= -1;
                }
                else if (doc["Side"].ToString() == "sell" && doc["OrderType"].ToString() == "market")
                {
                    pos       = pos - executed;
                    executed *= -1;
                }
                else if (doc["Side"].ToString() == "buy" && doc["OrderType"].ToString() == "market")
                {
                    pos = pos + executed;
                }
                else
                {
                    return(BadRequest("error"));
                }

                posupdate["Email"]     = doc["Email"].ToString();
                posupdate["POSSPXUSD"] = pos.ToString();
                //await postable.UpdateItemAsync(posupdate);

                if (pos == 0)
                {
                    posupdate["POSSPXUSDEntry"] = "na";
                }                                                                                                          // closed out pos
                else if ((pos - executed) == 0 || (pos + executed) == 0 || (pos - executed) == 0 || (pos + executed) == 0) /*open pos from 0*/
                {
                    posupdate["POSSPXUSDEntry"] = Price;
                }
                else if ((pos - executed) > 0 || (pos + executed) < 0 || (pos - executed) < 0 || (pos + executed) > 0)                                                                                                                                                      /*pre-existing pos non zero*/
                {
                    if ((Math.Abs(posdoc["POSSPXUSD"].AsDouble()) > Math.Abs(executed) || (Math.Abs(posdoc["POSSPXUSD"].AsDouble()) < Math.Abs(executed) && ((posdoc["POSSPXUSD"].AsDouble() > 0 && executed > 0) || posdoc["POSSPXUSD"].AsDouble() < 0 && executed < 0)))) // reduce or add
                    {
                        if (pos > 0)
                        {
                            double newentry = ((posdoc["POSSPXUSD"].AsDouble() * posdoc["POSSPXUSDEntry"].AsDouble()) + (executed * price)) / (posdoc["POSSPXUSD"].AsDouble() + executed);
                            if ((pos > 0 && (pos - posdoc["POSSPXUSD"].AsDouble() > 0)) || (pos < 0 && (pos - posdoc["POSSPXUSD"].AsDouble() < 0)))/*if add*/
                            {
                                posupdate["POSSPXUSDEntry"] = newentry.ToString();
                            }
                            else // profit/loss
                            {
                            }
                        }
                        else if (pos < 0)
                        {
                            double newentry = ((posdoc["POSSPXUSD"].AsDouble() * posdoc["POSSPXUSDEntry"].AsDouble()) + (executed * price)) / (posdoc["POSSPXUSD"].AsDouble() + executed);
                            if ((pos > 0 && (pos - posdoc["POSSPXUSD"].AsDouble() > 0)) || (pos < 0 && (pos - posdoc["POSSPXUSD"].AsDouble() < 0)))/*if add*/
                            {
                                posupdate["POSSPXUSDEntry"] = newentry.ToString();
                            }
                            else // profit/loss
                            {
                            }
                        }
                        else
                        {
                            Console.WriteLine("error calc entry");
                        }
                    }
                    else // reduce and add
                    {
                        if (pos > 0)
                        {
                            //reduce
                            double posremain = (executed * -1) - posdoc["POSSPXUSD"].AsDouble();

                            //add
                            posupdate["POSSPXUSD"]      = (0 - posremain).ToString();
                            posupdate["POSSPXUSDEntry"] = Price;
                        }
                        else if (pos < 0)
                        {
                            //reduce
                            double posremain = executed - (posdoc["POSSPXUSD"].AsDouble() * -1);

                            //add
                            posupdate["POSSPXUSD"]      = (0 + posremain).ToString();
                            posupdate["POSSPXUSDEntry"] = Price;
                        }
                    }
                }

                // pull from database and calculate new position value.
                UpdateItemOperationConfig update   = new UpdateItemOperationConfig();
                ExpectedValue             expected = new ExpectedValue(ScanOperator.Equal);
                update.Expected = posdoc;
                try
                { Document test = await postable.UpdateItemAsync(posupdate, update); }
                catch
                {
                    Thread.Sleep(20);
                    Console.WriteLine("error");
                    posdoc = await postable.GetItemAsync(doc["Email"].ToString());

                    posupdate = new Document();

                    try
                    {
                        posdoc["POSSPXUSD"].ToString();
                        if (posdoc["POSSPXUSD"].ToString() == "0")
                        {
                            throw new Exception();
                        }
                        pos = posdoc["POSSPXUSD"].AsDouble();
                    }
                    catch //never position or 0 position
                    {
                        pos = 0;
                    }

                    try { executed = double.Parse(Executed); } catch { return(BadRequest("error parse")); }

                    if (doc["Side"].ToString() == "buy" && doc["OrderType"].ToString() == "limit")
                    {
                        pos = pos + executed;
                    }
                    else if (doc["Side"].ToString() == "sell" && doc["OrderType"].ToString() == "limit")
                    {
                        pos       = pos - executed;
                        executed *= -1;
                    }
                    else if (doc["Side"].ToString() == "sell" && doc["OrderType"].ToString() == "market")
                    {
                        pos       = pos - executed;
                        executed *= -1;
                    }
                    else if (doc["Side"].ToString() == "buy" && doc["OrderType"].ToString() == "market")
                    {
                        pos = pos + executed;
                    }
                    else
                    {
                        return(BadRequest("error"));
                    }

                    posupdate["Email"]     = doc["Email"].ToString();
                    posupdate["POSSPXUSD"] = pos.ToString();

                    if (pos == 0)
                    {
                        posupdate["POSSPXUSDEntry"] = "na";
                    }                                                                                                          // closed out pos
                    else if ((pos - executed) == 0 || (pos + executed) == 0 || (pos - executed) == 0 || (pos + executed) == 0) /*open pos from 0*/
                    {
                        posupdate["POSSPXUSDEntry"] = Price;
                    }
                    else if ((pos - executed) > 0 || (pos + executed) < 0 || (pos - executed) < 0 || (pos + executed) > 0)                                                                                                                                                      /*pre-existing pos non zero*/
                    {
                        if ((Math.Abs(posdoc["POSSPXUSD"].AsDouble()) > Math.Abs(executed) || (Math.Abs(posdoc["POSSPXUSD"].AsDouble()) < Math.Abs(executed) && ((posdoc["POSSPXUSD"].AsDouble() > 0 && executed > 0) || posdoc["POSSPXUSD"].AsDouble() < 0 && executed < 0)))) // reduce or add
                        {
                            if (pos > 0)
                            {
                                double newentry = ((posdoc["POSSPXUSD"].AsDouble() * posdoc["POSSPXUSDEntry"].AsDouble()) + (executed * price)) / (posdoc["POSSPXUSD"].AsDouble() + executed);
                                if ((pos > 0 && (pos - posdoc["POSSPXUSD"].AsDouble() > 0)) || (pos < 0 && (pos - posdoc["POSSPXUSD"].AsDouble() < 0)))/*if add*/
                                {
                                    posupdate["POSSPXUSDEntry"] = newentry.ToString();
                                }
                                else // profit/loss
                                {
                                }
                            }
                            else if (pos < 0)
                            {
                                double newentry = ((posdoc["POSSPXUSD"].AsDouble() * posdoc["POSSPXUSDEntry"].AsDouble()) + (executed * price)) / (posdoc["POSSPXUSD"].AsDouble() + executed);
                                if ((pos > 0 && (pos - posdoc["POSSPXUSD"].AsDouble() > 0)) || (pos < 0 && (pos - posdoc["POSSPXUSD"].AsDouble() < 0)))/*if add*/
                                {
                                    posupdate["POSSPXUSDEntry"] = newentry.ToString();
                                }
                                else // profit/loss
                                {
                                }
                            }
                            else
                            {
                                Console.WriteLine("error calc entry");
                            }
                        }
                        else // reduce and add
                        {
                            if (pos > 0)
                            {
                                //reduce
                                double posremain = (executed * -1) - posdoc["POSSPXUSD"].AsDouble();

                                //add
                                posupdate["POSSPXUSD"]      = (0 - posremain).ToString();
                                posupdate["POSSPXUSDEntry"] = Price;
                            }
                            else if (pos < 0)
                            {
                                //reduce
                                double posremain = executed - (posdoc["POSSPXUSD"].AsDouble() * -1);

                                //add
                                posupdate["POSSPXUSD"]      = (0 + posremain).ToString();
                                posupdate["POSSPXUSDEntry"] = Price;
                            }
                        }
                    }

                    await postable.UpdateItemAsync(posupdate);
                }

                return(Ok());
            }
            catch
            {
                return(BadRequest("something went wrong"));
            }
        }
Exemple #20
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="input"></param>
        /// <param name="context"></param>
        /// <returns></returns>
        public async Task FunctionHandler(S3Event input, ILambdaContext context)
        {
            // Initialize the Amazon Cognito credentials provider
            CognitoAWSCredentials credentials = new CognitoAWSCredentials(
                "us-east-1:6d711ae9-1084-4a71-9ef6-7551ca74ad0b", // Identity pool ID
                RegionEndpoint.USEast1                            // Region
                );

            dynamoDbClient = new AmazonDynamoDBClient(credentials, RegionEndpoint.USEast1);
            Table customersTbl = Table.LoadTable(dynamoDbClient, "Customer");


            AmazonRekognitionClient rekognitionClient = new AmazonRekognitionClient();
            IAmazonS3 s3Client = new AmazonS3Client(RegionEndpoint.USEast2);

            //Debug.WriteLine("Creating collection: " + FACE_COLLECTION_ID);
            //CreateCollectionRequest createCollectionRequest = new CreateCollectionRequest()
            //{
            //    CollectionId = FACE_COLLECTION_ID
            //};

            //CreateCollectionResponse createCollectionResponse = rekognitionClient.CreateCollectionAsync(createCollectionRequest).Result;
            //Debug.WriteLine("CollectionArn : " + createCollectionResponse.CollectionArn);
            //Debug.WriteLine("Status code : " + createCollectionResponse.StatusCode);


            foreach (var record in input.Records)
            {
                //if(!SupportedImageTypes.Contains(Path.GetExtension(record.S3.Object.Key)))
                //{
                //    Debug.WriteLine($"Object {record.S3.Bucket.Name}:{record.S3.Object.Key} is not a supported image type");
                //    continue;
                //}

                Image image = new Image()
                {
                    S3Object = new Amazon.Rekognition.Model.S3Object
                    {
                        Bucket = record.S3.Bucket.Name,
                        Name   = record.S3.Object.Key
                    }
                };

                GetObjectTaggingResponse taggingResponse = s3Client.GetObjectTaggingAsync(
                    new GetObjectTaggingRequest
                {
                    BucketName = record.S3.Bucket.Name,
                    Key        = record.S3.Object.Key
                }
                    ).Result;

                Tag customerID = taggingResponse.Tagging[0];//TODO: HARDCODING!!


                IndexFacesRequest indexFacesRequest = new IndexFacesRequest()
                {
                    Image               = image,
                    CollectionId        = FACE_COLLECTION_ID,
                    ExternalImageId     = record.S3.Object.Key,
                    DetectionAttributes = new List <String>()
                    {
                        "ALL"
                    }
                };

                IndexFacesResponse indexFacesResponse = rekognitionClient.IndexFacesAsync(indexFacesRequest).Result;

                Debug.WriteLine(record.S3.Object.Key + " added");
                foreach (FaceRecord faceRecord in indexFacesResponse.FaceRecords)
                {
                    Debug.WriteLine("Face detected: Faceid is " + faceRecord.Face.FaceId);

                    Console.WriteLine("\nAfter Indexing, Updating FaceID of the Customer....");
                    string partitionKey = customerID.Value;

                    var customer = new Document();
                    customer["Id"] = Int32.Parse(partitionKey);
                    // List of attribute updates.
                    // The following replaces the existing authors list.
                    customer["FaceId"] = faceRecord.Face.FaceId;

                    // Optional parameters.
                    UpdateItemOperationConfig config = new UpdateItemOperationConfig
                    {
                        // Get updated item in response.
                        ReturnValues = ReturnValues.AllNewAttributes
                    };
                    Document updatedCustomer = customersTbl.UpdateItemAsync(customer, config).Result;
                    Console.WriteLine("UpdateMultipleAttributes: Printing item after updates ...");
                    PrintDocument(updatedCustomer);
                }
            }
            return;
        }
Exemple #21
0
        private async void ButtonSubmit_Click(object sender, RoutedEventArgs e)
        {
            //MessageBox.Show("this is submit button");
            String name = txtName.Text;

            //MessageBox.Show(name);

            try
            {
                bool isNameEmpty        = string.IsNullOrEmpty(txtName.Text);
                bool isPhoneEmpty       = string.IsNullOrEmpty(txtPhone.Text);
                bool isDescriptionEmpty = string.IsNullOrEmpty(txtDescription.Text);
                bool isFilePathEmpty    = string.IsNullOrEmpty(uploadFilePath);
                bool isFileIdEmpty      = string.IsNullOrEmpty(txtId.Text);

                if (!isNameEmpty && !isDescriptionEmpty && !isPhoneEmpty)
                {
                    string tableName = MyAWSConfigs.ReaderDBtableName;
                    Table  table     = Table.LoadTable(client, tableName);

                    ProgressDialogController controller = await this.ShowProgressAsync("Please wait...", "");

                    controller.SetIndeterminate();
                    controller.SetCancelable(false);


                    string partitionKey = txtId.Text;
                    Console.WriteLine("oooooooooooooooooooooooooooooooo" + partitionKey);

                    var item = new Document();

                    Document doc = new Document();
                    doc["id"]          = partitionKey;
                    doc["name"]        = txtName.Text;
                    doc["phone"]       = txtPhone.Text;
                    doc["description"] = txtDescription.Text;
                    ///////////////////////////////////////////////////       //#ToDo : Add readerList
                    //item["readerList"] = readerList;

                    UpdateItemOperationConfig config = new UpdateItemOperationConfig
                    {
                        // Get updated item in response.
                        ReturnValues = ReturnValues.AllNewAttributes
                    };

                    if (uploadFilePath != null)
                    {
                        string[] temp = uploadFilePath.Split('.');
                        string   BaseDirectoryPath = AppDomain.CurrentDomain.BaseDirectory;
                        string   filePath          = BaseDirectoryPath + $"Resources\\Images\\{partitionKey}";
                        item = table.GetItem(partitionKey);
                        string oldImage = item["aPropic"];
                        Console.WriteLine("><><><><><><><><><><>" + oldImage);

                        //Delete old profile pic in local
                        string oldFilePath = BaseDirectoryPath + $"Resources\\Images\\{oldImage}";
                        DeleteOldPic(oldFilePath);

                        //Delete old profile pic in s3Bucket
                        controller.SetMessage("Deleting File");
                        await Task.Run(() => S3Bucket.DeleteFile(oldImage, MyAWSConfigs.RefImagesBucketName));


                        controller.SetMessage("Uploading file");
                        await Task.Run(() => Models.S3Bucket.UploadFile(uploadFilePath, partitionKey, Models.MyAWSConfigs.RefImagesBucketName));
                    }

                    controller.SetMessage("Adding database record");
                    await Task.Run(() => table.UpdateItem(doc, config));

                    Console.WriteLine("UpdateMultipleAttributes: Printing item after updates ...");
                    //MessageBox.Show("Successfully Updated!");

                    await controller.CloseAsync();

                    await this.ShowMessageAsync("Success", "Person Updated !", MessageDialogStyle.Affirmative);
                }
                else
                {
                    await this.ShowMessageAsync("Error", "Please check all fields", MessageDialogStyle.Affirmative);
                }
            }
            catch
            {
                await this.ShowMessageAsync("Error", "Task not completed", MessageDialogStyle.Affirmative);
            }
        }
Exemple #22
0
        public async Task <IActionResult> PostOrder([FromHeader] string Authorization, [FromBody] OrderPost orderPost)
        {
            try
            {
                long timestamp          = (long)DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1)).TotalSeconds;
                long markpricetimestamp = timestamp;// - DateTime.UtcNow.Second;

                if (Request.ContentType == "application/json")
                {
                    ;
                }
                else
                {
                    return(BadRequest("improper content type"));
                }

                if (orderPost.OrderType == "limit")
                {
                    if (string.IsNullOrEmpty(orderPost.Contract) && string.IsNullOrEmpty(orderPost.OrderType) && string.IsNullOrEmpty(orderPost.Price) && orderPost.OrderQuantity == null)
                    {
                        return(BadRequest("bad params"));
                    }
                }
                else if (orderPost.OrderType == "market")
                {
                    if (string.IsNullOrEmpty(orderPost.Contract) && string.IsNullOrEmpty(orderPost.OrderType) && orderPost.OrderQuantity == null)
                    {
                        return(BadRequest("bad params"));
                    }
                }
                else
                {
                    return(BadRequest("missing params"));
                }

                Console.WriteLine(orderPost.Contract + orderPost.OrderQuantity + orderPost.OrderType + orderPost.Side);
                if (string.IsNullOrEmpty(orderPost.Contract) || string.IsNullOrEmpty(orderPost.OrderType) || string.IsNullOrEmpty(orderPost.Side) || orderPost.OrderQuantity == null)
                {
                    return(BadRequest("missing variables"));
                }

                AmazonDynamoDBClient amazonDynamoDBClient = new AmazonDynamoDBClient();
                Table    UserTable     = Table.LoadTable(amazonDynamoDBClient, "UserDetailsRegistry");
                Table    SPXMarkTable  = Table.LoadTable(amazonDynamoDBClient, "SPXMarkPrice");
                Document searchdetails = new Document();

                orderPost.OrderType = orderPost.OrderType.ToLower();

                int    orderId;
                string socket;

                try
                {
                    string[] autharray  = Authorization.Split(' ');
                    string   authtype   = autharray[0];
                    string   authstring = autharray[1];

                    if (authtype == "Basic")
                    {
                        byte[] data          = Convert.FromBase64String(authstring);
                        string decodedString = Encoding.UTF8.GetString(data);

                        string[] splitauth = decodedString.Split(":");
                        string   id        = splitauth[0];
                        string   secret    = splitauth[1]; Console.WriteLine(id + secret);

                        ScanOperationConfig scanOperation = new ScanOperationConfig();
                        ScanFilter          scanFilter    = new ScanFilter();
                        scanFilter.AddCondition("DefaultId", ScanOperator.Equal, id);
                        Search          search  = UserTable.Scan(scanOperation);
                        List <Document> details = await search.GetRemainingAsync();

                        foreach (Document doc in details)
                        {
                            if (doc["DefaultSecret"] == secret && doc["DefaultId"] == id)
                            {
                                Console.WriteLine("successful auth");
                                searchdetails = doc;
                                break;
                            }
                            else
                            {
                                continue;
                            }
                        }
                        searchdetails["Email"].ToString();
                    }
                    else
                    {
                        return(BadRequest("Bad authorization"));
                    }

                    // verifiy valid account balance
                    Document userdetails = await UserTable.GetItemAsync(searchdetails["Email"].ToString());

                    Document markprice = new Document();
                    markpricetimestamp = markpricetimestamp - (markpricetimestamp % 5);
                    try { markprice = await SPXMarkTable.GetItemAsync(markpricetimestamp.ToString()); markprice["BTCPrice"].ToString(); }
                    catch { try { markpricetimestamp -= 5; markprice = await SPXMarkTable.GetItemAsync((markpricetimestamp).ToString()); markprice["BTCPrice"].ToString(); } catch { Console.WriteLine("bigbad"); } }

                    double availablebalance = searchdetails["AvailableBalance"].AsDouble();
                    if (orderPost.OrderQuantity > ((availablebalance * markprice["BTCPrice"].AsDouble()) * 100))
                    {
                        return(BadRequest("bad amount"));
                    }

                    // atomic id generate
                    Table    idgenerator = Table.LoadTable(amazonDynamoDBClient, "IdGenerator");
                    Document currentid   = await idgenerator.GetItemAsync("Main");

                    Document newid = new Document();
                    newid["Id"] = "Main";

                    double count = currentid["Count"].AsDouble();
                    count         += 1;
                    newid["Count"] = count.ToString();

                    UpdateItemOperationConfig updateItemOperationConfig = new UpdateItemOperationConfig();
                    ExpectedValue             expected = new ExpectedValue(ScanOperator.Equal);
                    updateItemOperationConfig.Expected = currentid;

                    try
                    {
                        Document test = await idgenerator.UpdateItemAsync(newid, updateItemOperationConfig);

                        orderId = (int)count;
                    }
                    catch
                    {
                        return(BadRequest("please try again"));
                    }

                    Table    orderreg = Table.LoadTable(amazonDynamoDBClient, "OrderRegistry");
                    Document addorder = new Document();
                    addorder["Id"]    = orderId.ToString();
                    addorder["Email"] = searchdetails["Email"].ToString();
                    addorder["Side"]  = orderPost.Side.ToString();
                    if (orderPost.OrderType == "limit")
                    {
                        addorder["Price"] = orderPost.Price.ToString();
                    }
                    addorder["OrderQuantity"] = orderPost.OrderQuantity.ToString();
                    addorder["Contract"]      = orderPost.Contract;
                    addorder["OrderType"]     = orderPost.OrderType;
                    addorder["Status"]        = "open";
                    addorder["Timestamp"]     = timestamp.ToString();
                    //addorder["Add"] = "true";
                    await orderreg.PutItemAsync(addorder);

                    // send tcp message to engine
                    try
                    {
                        TcpClient tcpclnt = new TcpClient();
                        Console.WriteLine("Connecting.....");

                        tcpclnt.Connect("52.213.34.99", port);
                        // use the ipaddress as in the server program

                        Console.WriteLine("Connected");
                        Console.Write("Enter the string to be transmitted : ");
                        var    enginepayload = new object();
                        double spymark       = markprice["SPXPrice"].AsDouble();
                        spymark  = Math.Round(spymark);
                        spymark *= 100;

                        if (orderPost.OrderType == "limit")
                        {
                            enginepayload = new
                            {
                                Method        = "Post",
                                Side          = orderPost.Side,
                                Id            = orderId.ToString(),
                                Price         = orderPost.Price,
                                OrderQuantity = orderPost.OrderQuantity.ToString(),
                                OrderType     = orderPost.OrderType,
                                Contract      = orderPost.Contract,
                                Secret        = "secret",
                                //Timestamp = timestamp.ToString(),
                                //User = searchdetails["Email"].ToString(),
                                //AvailableBalance = searchdetails["AvailableBalance"].ToString()
                            };
                        }
                        else if (orderPost.OrderType == "market")
                        {
                            enginepayload = new
                            {
                                Method        = "Post",
                                Side          = orderPost.Side,
                                Id            = orderId.ToString(),
                                OrderQuantity = orderPost.OrderQuantity.ToString(),
                                Slippage      = 99999.ToString(),
                                OrderType     = orderPost.OrderType,
                                Contract      = orderPost.Contract,
                                Secret        = "secret",
                                //Timestamp = timestamp.ToString(),
                                //User = searchdetails["Email"].ToString(),
                                //AvailableBalance = searchdetails["AvailableBalance"].ToString()
                            };
                        }
                        else
                        {
                            return(BadRequest("invalid order type"));
                        }

                        using (SslStream sslStream = new SslStream(tcpclnt.GetStream(), false,
                                                                   new RemoteCertificateValidationCallback(ValidateServerCertificate), null))
                        {
                            sslStream.AuthenticateAsClient("52.213.34.99");
                            // This is where you read and send data

                            String str = "enginekey" + JsonConvert.SerializeObject(enginepayload);
                            //Stream stm = tcpclnt.GetStream();

                            ASCIIEncoding asen = new ASCIIEncoding();
                            byte[]        ba   = asen.GetBytes(str);
                            Console.WriteLine("Transmitting.....");

                            sslStream.Write(ba, 0, ba.Length);
                            //sslStream.Close();

                            /*byte[] bb = new byte[1000];
                             * int k = await sslStream.ReadAsync(bb, 0, 1000);
                             *
                             * var socketresult = Encoding.UTF8.GetString(bb).TrimEnd('\0');
                             * Console.WriteLine(socketresult);
                             * socket = socketresult;*/
                        }
                        tcpclnt.Close();
                    }

                    catch (Exception e)
                    {
                        Console.WriteLine("Error..... " + e.StackTrace);
                        return(BadRequest("error with engine"));
                    }
                }
                catch
                {
                    return(BadRequest("failed processing"));
                }

                var    returnobj  = new { Id = orderId, Timestamp = markpricetimestamp.ToString(), Message = "transmitted", Result = "sucess" };
                string returnjson = JsonConvert.SerializeObject(returnobj);
                return(Content(returnjson, "application/json"));
            }
            catch
            {
                return(BadRequest("something went wrong"));
            }
        }
        public async Task <NumberPlateTrigger> FunctionHandler(NumberPlateTrigger payload, ILambdaContext context)
        {
            Random rand = new Random((Int32)(DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1))).TotalSeconds);

            if (rand.NextDouble() > double.Parse(Environment.GetEnvironmentVariable("RandomProcessingErrorProbability")))
            {
                string message = "Congratulations! A random processing error occurred!";
                context.Logger.LogLine(message);
                ////////////////////////////////////////////////////////////
                //
                // TODO: Return 'RandomProcessingError' error
                ///
                /////////////////////////////////////////////////////////////
            }
            Table    table;
            Document document;

            try
            {
                table    = Table.LoadTable(dbClient, Environment.GetEnvironmentVariable("DDBTableName"));
                document = await table.GetItemAsync(payload.numberPlate.numberPlateString);

                if (document != null)
                {
                    if (float.Parse(document["credit"]) > payload.charge)
                    {
                        var item = document;
                        item["credit"] = float.Parse(document["credit"]) - payload.charge;
                        Expression expr = new Expression();
                        expr.ExpressionStatement = "credit >= :charge";
                        expr.ExpressionAttributeValues[":charge"] = payload.charge;

                        // Optional parameters.
                        UpdateItemOperationConfig config = new UpdateItemOperationConfig
                        {
                            ConditionalExpression = expr,
                            ReturnValues          = ReturnValues.AllNewAttributes
                        };
                        Document updatedRecord = await table.UpdateItemAsync(item, config);

                        //
                        // Success!
                        //
                        context.Logger.LogLine("Charge of $$" + payload.charge + " deducted from credit for " + payload.numberPlate.numberPlateString);
                    }
                    else
                    {
                        string message = "Driver for number plate " + payload.numberPlate.numberPlateString + "(" + document["ownerFirstName"] + ")" + document["ownerLastName"] + ") has insufficient credit (" + document["credit"] + ") for a charge of " + payload.charge;
                        context.Logger.LogLine(message);
                        /////////////////////////////////////////////////////////////
                        //
                        // TODO: Return 'InsufficientCreditError' error
                        //
                        /////////////////////////////////////////////////////////////
                    }
                }
                else
                {
                    string message = "Number plate " + payload.numberPlate.numberPlateString + "was not found. This will require manual resolution.";
                    context.Logger.LogLine(message);
                    /////////////////////////////////////////////////////////////
                    //
                    // TODO: Return 'UnknownNumberPlateError' error
                    //
                    /////////////////////////////////////////////////////////////
                }
            }
            catch (AmazonDynamoDBException e)
            {
                context.Logger.LogLine(e.StackTrace);
                ////////////////////////////////////////////////////////////
                //
                // TODO: Return 'DatabaseAccessError' error
                ///
                /////////////////////////////////////////////////////////////
            }
            catch (Exception e)
            {
                context.Logger.LogLine(e.StackTrace);
                ////////////////////////////////////////////////////////////
                //
                // TODO: Return 'GenericError' error
                ///
                /////////////////////////////////////////////////////////////
            }

            return(payload);
        }
Exemple #24
0
        private void GiveRedersToRefernces(List <String> refList, String readerId)
        {
            try
            {
                Console.WriteLine(readerId);
                foreach (String chkd_ref in refList)
                {
                    string tableName = MyAWSConfigs.RefPersonsDBTableName;
                    Table  table     = Table.LoadTable(client, tableName);

                    Console.WriteLine("\n*** Executing UpdateMultipleAttributes() ***");
                    Console.WriteLine("\nUpdating multiple attributes....");
                    string partitionKey = chkd_ref;

                    Document doc = new Document();
                    doc["id"] = partitionKey;
                    // List of attribute updates.
                    // The following replaces the existing authors list.

                    Item item = table.GetItem(chkd_ref);
                    Console.WriteLine(item["id"]);
                    //Console.WriteLine(item["readerList"]);
                    List <string> readersList = new List <string>();
                    if (item["readerList"] != null)
                    {
                        readersList = item["readerList"].AsListOfString();
                        var match = readersList.FirstOrDefault(stringToCheck => stringToCheck.Contains(readerId));
                        if (match != null)
                        {
                            readersList.Add(readerId);
                            foreach (string i in readersList)
                            {
                                Console.WriteLine("reader !match >>>>>> " + i);
                            }
                            doc["readerList"] = readersList;
                            // Optional parameters.
                            UpdateItemOperationConfig config = new UpdateItemOperationConfig
                            {
                                // Get updated item in response.
                                ReturnValues = ReturnValues.AllNewAttributes
                            };
                            Document updatedadmin = table.UpdateItem(doc, config);
                            Console.WriteLine("UpdateMultipleAttributes: Printing item after updates ...");
                            //MessageBox.Show("Successfully Updated! not null");
                        }
                        else
                        {
                            readersList.Add(readerId);
                            foreach (string i in readersList)
                            {
                                Console.WriteLine("reader match >>>>>> " + i);
                            }
                            doc["readerList"] = readersList;
                            // Optional parameters.
                            UpdateItemOperationConfig config = new UpdateItemOperationConfig
                            {
                                // Get updated item in response.
                                ReturnValues = ReturnValues.AllNewAttributes
                            };
                            Document updatedadmin = table.UpdateItem(doc, config);
                            Console.WriteLine("UpdateMultipleAttributes: Printing item after updates ...");
                            //MessageBox.Show("Successfully Updated! not null");
                        }
                    }
                    else
                    {
                        foreach (string i in readersList)
                        {
                            Console.WriteLine("reader null >>>>>> " + i);
                        }

                        doc["readerList"] = readersList;
                        // Optional parameters.
                        UpdateItemOperationConfig config = new UpdateItemOperationConfig
                        {
                            // Get updated item in response.
                            ReturnValues = ReturnValues.AllNewAttributes
                        };
                        Document updatedadmin = table.UpdateItem(doc, config);
                        Console.WriteLine("UpdateMultipleAttributes: Printing item after updates ...");
                        MessageBox.Show("Successfully Updated! null");
                    }
                }
            }
            catch (AmazonDynamoDBException ex)
            {
                MessageBox.Show("Message : Server Error", ex.Message);
            }
            catch (Exception ex)
            {
                //MessageBox.Show("Message : Unknown Error- Updating Refs", ex.Message);
            }
            finally
            {
            }
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="input"></param>
        /// <param name="context"></param>
        /// <returns></returns>
        public async Task FunctionHandler(S3Event input, ILambdaContext context)
        {
            try
            {
                AmazonRekognitionClient rekognitionClient = new AmazonRekognitionClient();

                //Debug.WriteLine("Creating collection: " + FACE_COLLECTION_ID);
                //CreateCollectionRequest createCollectionRequest = new CreateCollectionRequest()
                //{
                //    CollectionId = FACE_COLLECTION_ID
                //};

                //CreateCollectionResponse createCollectionResponse = rekognitionClient.CreateCollectionAsync(createCollectionRequest).Result;
                //Debug.WriteLine("CollectionArn : " + createCollectionResponse.CollectionArn);
                //Debug.WriteLine("Status code : " + createCollectionResponse.StatusCode);

                foreach (var record in input.Records)
                {
                    if (!SupportedImageTypes.Contains(Path.GetExtension(record.S3.Object.Key)))
                    {
                        Debug.WriteLine($"Object {record.S3.Bucket.Name}:{record.S3.Object.Key} is not a supported image type");
                        continue;
                    }

                    Image image = new Image()
                    {
                        S3Object = new Amazon.Rekognition.Model.S3Object
                        {
                            Bucket = record.S3.Bucket.Name,
                            Name   = record.S3.Object.Key
                        }
                    };

                    SearchFacesByImageRequest searchFacesByImageRequest = new SearchFacesByImageRequest()
                    {
                        CollectionId       = FACE_COLLECTION_ID,
                        Image              = image,
                        FaceMatchThreshold = 90F,
                        MaxFaces           = 1
                    };

                    SearchFacesByImageResponse searchFacesByImageResponse = rekognitionClient.SearchFacesByImageAsync(searchFacesByImageRequest).Result;

                    Debug.WriteLine("Faces matching largest face in image from " + record.S3.Object.Key);
                    foreach (FaceMatch match in searchFacesByImageResponse.FaceMatches)
                    {
                        Debug.WriteLine("FaceId: " + match.Face.FaceId + ", Similarity: " + match.Similarity);

                        // Initialize the Amazon Cognito credentials provider
                        CognitoAWSCredentials credentials = new CognitoAWSCredentials(
                            "us-east-1:6d711ae9-1084-4a71-9ef6-7551ca74ad0b", // Identity pool ID
                            RegionEndpoint.USEast1                            // Region
                            );

                        var   dynamoDbClient = new AmazonDynamoDBClient(credentials, RegionEndpoint.USEast1);
                        Table customersTbl   = Table.LoadTable(dynamoDbClient, "Customer");


                        GetItemOperationConfig config = new GetItemOperationConfig
                        {
                            AttributesToGet = new List <string> {
                                "Id", "CustomerName", "FaceId", "StoreLocation"
                            },
                            ConsistentRead = true
                        };

                        for (int i = 1; i <= 5; i++)
                        {
                            Document retrievedCustomer = customersTbl.GetItemAsync(i, config).Result;
                            if (retrievedCustomer["FaceId"].AsString() == match.Face.FaceId)//retrieved customer's faceID matches with the faceId currently being searched - we know who's in the store
                            {
                                //let us update customer's location
                                var customer = new Document();
                                customer["Id"] = Int32.Parse(retrievedCustomer["Id"].AsString());

                                string   location             = "";
                                string   cameraFeedFolder     = "CAM-Exit";
                                string[] cameraFeedFolderPath = record.S3.Object.Key.Split("/");
                                if (cameraFeedFolderPath.Length > 0)
                                {
                                    cameraFeedFolder = cameraFeedFolderPath[0];
                                }
                                switch (cameraFeedFolder)
                                {
                                case "CAM-Entrance":
                                    location = "entrance";
                                    break;

                                case "CAM-Aisle1":
                                    location = "aisle1";
                                    break;

                                case "CAM-Aisle2":
                                    location = "aisle2";
                                    break;

                                case "CAM-Aisle3":
                                    location = "aisle3";
                                    break;

                                case "CAM-Aisle4":
                                    location = "aisle4";
                                    break;

                                case "CAM-Checkout":
                                    location = "checkout";
                                    break;

                                default:
                                    location = "entrance";
                                    break;
                                }

                                customer["StoreLocation"] = location;

                                // Optional parameters.
                                UpdateItemOperationConfig updateConfig = new UpdateItemOperationConfig
                                {
                                    // Get updated item in response.
                                    ReturnValues = ReturnValues.AllNewAttributes
                                };
                                Document updatedCustomer = customersTbl.UpdateItemAsync(customer, updateConfig).Result;
                                Console.WriteLine("UpdateMultipleAttributes: Printing item after updates ...");
                                PrintDocument(updatedCustomer);
                                break;
                            }
                        }
                    }
                }
                return;
            }
            catch (Exception ex)
            {
                throw new Exception("Deloitte Mart Exception " + ex.Message, ex);
            }
        }