def __init__(self):
endpoint = "https://synapsel1nk1.documents.azure.com:443/"
key = "zM8dZNCWIi03JWziWAr2JGBlU2uEsmU1651YA4p5HCKp1DpGeQ0fH3gNDCHVEId5JIhHXhTI7Rkfnl4pZurqfg=="
# create_cosmos_client
client = CosmosClient(endpoint, key)
database_name = 'lvtn_database'
client.create_database_if_not_exists(database_name)
database = client.get_database_client(database_name)
container_name = 'parsed_data'
self.container = database.get_container_client(container_name)
def __init__(self):
endpoint = "https://synapsel1nk.documents.azure.com:443/"
key = "r0EEApAfBwKARscLmgjPzdAYVVxFbLy5pOf2AU0yLL6FrcHFjySI3NYnb5zpHSvVPFkvRKI4yUTTRIZTmt4mCg=="
# create_cosmos_client
client = CosmosClient(endpoint, key)
database_name = 'lvtn_database'
client.create_database_if_not_exists(database_name)
database = client.get_database_client(database_name)
container_name = 'parsed_data'
self.container = database.get_container_client(container_name)
def main(req: func.HttpRequest) -> func.HttpResponse:
# Initialize the Cosmos client
endpoint = "https://parking-spots.documents.azure.com:443/"
key = 'c9av0FP6xBrnz7XNUdBNIUFdCuo1IvE3H2SWvvB8Pxo92ALKzfW2gDXxgQlBlyUJtLDiJSZK6Ew8YO8yPNepnA=='
client = CosmosClient(endpoint, key)
# Select database
database_name = 'Parking-Data'
database = client.create_database_if_not_exists(id=database_name)
# Select container
container_name = 'Items'
container = database.create_container_if_not_exists(
id=container_name,
partition_key=PartitionKey(path="/slots"),
offer_throughput=400
)
# Query slots using SQL
query = "SELECT * FROM c"
items = list(container.query_items(
query=query,
enable_cross_partition_query=True
))
return func.HttpResponse(json.dumps(items))
def get_item(request, pk, name):
context = {'item': [], 'status_text': 'ok', 'created': {}}
client = CosmosClient(endpoint, key)
database = client.create_database_if_not_exists(id=database_name)
container = database.create_container_if_not_exists(
id=container_name,
partition_key=PartitionKey(path="/name"),
offer_throughput=400)
print(request)
if request.method == "DELETE":
print('delete')
try:
container.delete_item(item=pk, partition_key=name)
except CosmosResourceNotFoundError:
return HttpResponse("Resource not Found")
return redirect('http://127.0.0.1:8000')
# return render(request, template_name='index.html', context=context)
elif request.method == 'POST':
item = {
'id': request.POST.get('id'),
'name': request.POST.get('name'),
'age': request.POST.get('age'),
'category': request.POST.get('category'),
'picture': request.POST.get('picture')
}
# picture = request.FILES.get('picture')
# item = push_image(picture, request.POST['name'], request.POST['age'], request.POST['category'])
container.replace_item(item=item['id'], body=item)
context['item'] = [item]
return render(request, template_name='index.html', context=context)
else:
item = container.read_item(pk, partition_key=name)
context['item'] = item
return render(request, template_name='index.html', context=context)
def hello(request):
context = {'items': [], 'status_text': 'ok', 'created': {}}
client = CosmosClient(endpoint, key)
database = client.create_database_if_not_exists(id=database_name)
container = database.create_container_if_not_exists(
id=container_name,
partition_key=PartitionKey(path="/name"),
offer_throughput=400)
query = "SELECT * FROM c items"
items = list(
container.query_items(query=query, enable_cross_partition_query=True))
context['items'] = items
if request.method == 'GET':
return render(request, template_name='index.html', context=context)
elif request.method == 'POST':
picture = request.FILES.get('picture')
item = push_image(picture, request.POST['name'], request.POST['age'],
request.POST['category'])
container.upsert_item(body=item)
items.append(item)
context['items'] = items
return render(request, template_name='index.html', context=context)
elif request.method == 'PUT':
print(request.PUT)
pass
else:
pass
return render(request, template_name='index.html', context=context)
def main(req: func.HttpRequest) -> func.HttpResponse:
logging.info('Python HTTP trigger function processed a request.')
endpoint = os.environ["uri"]
key = os.environ["pkey"]
client = CosmosClient(endpoint, key)
database_name = 'usernames'
database = client.create_database_if_not_exists(id=database_name)
container_name = 'usernameStorage'
container = database.create_container_if_not_exists(id=container_name, partition_key=PartitionKey(path="/id"), offer_throughput=400)
getletters = requests.get('https://agris123.azurewebsites.net/api/service3?code=AfwsKOwVIblqhzmcOVH4IJxaFQ0eMIiNQdsA1RnWaIHtqQKICUbL3w==')
getnumbers = requests.get('https://agris123.azurewebsites.net/api/service2?code=LZAj225WWasaZLmUIOTMrpoeWOIMxQrwqir2TtFLdhiP8ufPqjKgTw==')
letters = getletters.text
numbers= getnumbers.text
answer = []
for i in range(5):
answer.append(letters[i])
answer.append(numbers[i])
ans="".join(answer)
ansItem = {'id': ans}
container.create_item(body=ansItem)
return str(ans)
def main(req: func.HttpRequest) -> func.HttpResponse:
logging.info('Python HTTP trigger function processed a request.')
id = str(req.route_params.get('id'))
if id:
endpoint = "https://localhost:8081"
key = os.environ['key']
client = CosmosClient(endpoint, key)
database_name = 'AzureDatabase'
database = client.create_database_if_not_exists(id=database_name)
container_name = 'DishesContainer'
container = database.create_container_if_not_exists(
id=container_name,
partition_key=PartitionKey(path="/name"),
offer_throughput=400)
query = "SELECT * FROM ALL"
items = list(
container.query_items(query=query,
enable_cross_partition_query=True))
for item in items:
if (str(item['id']) == id):
container.delete_item(item, item['name'])
return func.HttpResponse(f"Deleted dish having {id}!")
return func.HttpResponse("Element not found", status_code=404)
else:
return func.HttpResponse("Please pass a dish ID", status_code=400)
def __init___(image_name,section,label):
# Initialize the Cosmos client
endpoint = os.getenv('AZURE_DATABASE_URL')
key = os.getenv('AZURE_DATABASE_KEY')
# <create_cosmos_client>
client = CosmosClient(endpoint, key)
# </create_cosmos_client>
# Create a database
# <create_database_if_not_exists>
database_name = 'satlabelingdb'
database = client.create_database_if_not_exists(id=database_name)
# </create_database_if_not_exists>
# Create a container
# Using a good partition key improves the performance of database operations.
# <create_container_if_not_exists>
container_name = 'labelinfo'
container = database.create_container_if_not_exists(
id=container_name,
partition_key=PartitionKey(path="/info"),
offer_throughput=400
)
image_info = get_image_info_json(image_name,section,label)
read_item = container.read_item(item=image_name, partition_key=key)
if read_item:
container.replace_item(item=read_item, boby=image_info)
else:
container.create_item(body=image_info)
print("updated datbase")
def main(req: func.HttpRequest) -> func.HttpResponse:
logging.info('Python HTTP trigger function processed a request.')
con = 0
try:
req_body = req.get_json()
name = req_body['name']
dish = req_body['dish']
veg = req_body['vegetarian']
vegen = req_body['vegan']
except:
pass
else:
endpoint = "https://localhost:8081"
key = os.environ['key']
client = CosmosClient(endpoint, key)
database_name = 'AzureDatabase'
database = client.create_database_if_not_exists(id=database_name)
container_name = 'DishesContainer'
container = database.create_container_if_not_exists(
id=container_name,
partition_key=PartitionKey(path="/name"),
offer_throughput=400)
dish = new_item(name, dish, veg, vegen)
items = [dish]
for item in items:
container.create_item(body=item)
con = 1
if (con == 1):
return func.HttpResponse(f"Dish feeded")
else:
return func.HttpResponse(
"Please pass a valid query in the request body", status_code=400)
def add_to_db(message):
# Initialize the Cosmos client
endpoint = 'https://talkingdb.documents.azure.com:443/'
key = 'nL5f0ZJPKLwxSaKigi2BNlk9eVn5jtZCeoFIg85TeCC73vkBCy2BctEY27YDMCh8B4UXg8Gq1GvrNBeltrNYgg=='
#create cosmos client
client = CosmosClient(endpoint, key)
try:
# Create a database
database_name = 'tcdb'
database = client.create_database_if_not_exists(id=database_name)
except exceptions.CosmosResourceExistsError:
pass
# Create a container
# Using a good partition key improves the performance of database operations.
try:
container_name = 'c1'
container = database.create_container_if_not_exists(
id=container_name,
partition_key=PartitionKey(path="/messages"),
offer_throughput=400)
except exceptions.CosmosResourceExistsError:
pass
container.create_item(body=message)
def cosdb(db, ctr, prtn):
# Connect to a CosmosDB database and container
# Setup Logging
logging.basicConfig(level=os.environ.get("LOGLEVEL", "INFO"))
# Initialize the Cosmos client
endpoint = os.environ.get("OURO_DOCUMENTS_ENDPOINT",
"SET OURO_DOCUMENTS_ENDPOINT IN ENVIRONMENT")
key = os.environ.get("OURO_DOCUMENTS_KEY",
"SET OURO_DOCUMENTS_KEY IN ENVIRONMENT")
client = CosmosClient(endpoint, key)
database = client.create_database_if_not_exists(id=db)
# Connect to the daily_indicators container
try:
container = database.create_container_if_not_exists(
id=ctr,
partition_key=PartitionKey(path=prtn),
offer_throughput=400)
logging.info('Azure-Cosmos client initialized; connected to ' + db +
'.' + ctr + ' at ' + endpoint)
return container
except Exception as ex:
logging.critical('Unable to create connection to ' + db + '.' + ctr +
' at ' + endpoint)
logging.critical(ex)
quit(-1)
def database():
client = CosmosClient(ENDPOINT, KEY)
default_database_name = 'FastApiDB'
database = client.create_database_if_not_exists(id=default_database_name)
return database
def main(req: func.HttpRequest) -> func.HttpResponse:
logging.info('Python HTTP trigger function processed a request.')
name = req.params.get('name')
if not name:
try:
req_body = req.get_json()
except ValueError:
pass
else:
name = req_body.get('name')
if name:
return func.HttpResponse(
f"Hello, {name}. This HTTP triggered function executed successfully."
)
else:
endpoint = "https://pythondemo.documents.azure.com:443/"
key = 'Qyxm4LRY5vEh41KzNz6HMFzqCbzLZDorySjzm1sZ26QSVduiEUuLOl96y5YA7jSemG7NLPIimdEQXiRWeSU4qA=='
client = CosmosClient(endpoint, key)
database_name = 'pythondemo'
database = client.create_database_if_not_exists(id=database_name)
container_name = 'container1'
container = database.create_container_if_not_exists(
id=container_name,
partition_key=PartitionKey(path="/id"),
offer_throughput=400)
query = 'SELECT * FROM c WHERE c.name = "sneha"'
items = list(
container.query_items(query=query,
enable_cross_partition_query=True))
print("bla bla" + str(items))
return func.HttpResponse("success", status_code=200)
def __init__(self, endpoint, key, database_name, container_name):
self.key = key
self.database_name = database_name
client = CosmosClient(endpoint, key)
self.database = client.create_database_if_not_exists(id=database_name)
self.container = self.database.create_container_if_not_exists(
id=container_name,
partition_key=PartitionKey(path="/id"),
offer_throughput=400)
def main(req: func.HttpRequest) -> func.HttpResponse:
##SQL
conn = pyodbc.connect('Driver={SQL Server};'
'Server=.;'
'Database=StackOverflow;'
'Trusted_Connection=yes;')
cursor = conn.cursor()
cursor.execute("""SELECT (SELECT CAST([id] AS varchar(50)) AS [id]
,[AcceptedAnswerId]
,[AnswerCount]
,[Body]
,[ClosedDate]
,[CommentCount]
,[CommunityOwnedDate]
,[CreationDate]
,[FavoriteCount]
,[LastActivityDate]
,[LastEditDate]
,[LastEditorDisplayName]
,[LastEditorUserId]
,[OwnerUserId]
,[ParentId]
,[PostTypeId]
,[Score]
,[Tags]
,[Title]
,[ViewCount]
FOR JSON PATH, WITHOUT_ARRAY_WRAPPER) AS Result
FROM [StackOverflow].[dbo].[Posts] ORDER BY [id] ASC""")
##Cosmos
client = CosmosClient(os.environ["ACCOUNT_URI"], os.environ["ACCOUNT_KEY"], logging_enable=False)
database_name = 'StackOverflow'
database = client.create_database_if_not_exists(id=database_name)
container_name = 'Posts'
container = database.create_container_if_not_exists(
id=container_name,
partition_key=PartitionKey(path="/id"),
offer_throughput=400,
analytical_storage_ttl=-1
)
i = 0
startTime = datetime.now()
for row in cursor:
obj = json.loads(row.Result)
obj["ExtractionDate"] = datetime.now().isoformat()
container.create_item(obj,False)
i=i+1
if i%100==0:
logging.warning("{} elapse for the last 100 Posts insertions".format(datetime.now()-startTime))
startTime = datetime.now()
return func.HttpResponse(
"This HTTP triggered function executed successfully. Pass a name in the query string or in the request body for a personalized response.",
status_code=200
)
def main(req: func.HttpRequest) -> func.HttpResponse:
logging.info('Python HTTP trigger function processed a request.')
try:
req_body = req.get_json()
name = req_body['name']
email = req_body['email']
username = req_body['username']
password = req_body['password']
admin = req_body['admin']
adminpass = req_body['adminpass']
except:
return func.HttpResponse(
"Please pass all details name, email, username, password, admin, adminpass in the request body",
status_code=400)
if (str(admin + adminpass) != "abhishek0220createuser"):
return func.HttpResponse("Authentication Failed", status_code=401)
try:
endpoint = "https://*****:*****@binarybeasts.com',
to_emails=email,
subject='Welcome to QR Based Inventory',
html_content=
'Welcome to QR Based Inventory web application developed by Binary Beasts. Note down your Credientials - <br>Username : <strong>'
+ username + '</strong><br>Password : <strong>' + password +
'</strong><br>Link : <strong>' + link +
'</strong><br><br><br>Message by - Abhishek Chaudhary<br>[email protected]'
)
try:
sg = SendGridAPIClient(os.environ.get('SENDGRID_API_KEY'))
response = sg.send(message)
except Exception as e:
print(e.message)
return func.HttpResponse(f"User Added")
class CreateCosmosdbInstance:
def __init__(self,
uri=None,
key=None,
database_name="defaultpythondb",
container_name="defaultpythoncontainer",
**options):
self.uri = uri or os.environ.get('ACCOUNT_URI')
self.key = key or os.environ.get('ACCOUNT_KEY')
self.database_name = database_name
self.container_name = container_name
self.client = CosmosClient(self.uri, credential=key)
self.database_client = None
self.container_client = None
self.options_ = options
self.create_db_if_doest_not_exists()
self.create_container_if_does_not_exists()
def create_db_if_doest_not_exists(self, database_name=None, **options):
"""
Create a DB instance
:param database_name:
:return:
"""
self.database_name = database_name if database_name else self.database_name
self.database_client = self.client.create_database_if_not_exists(
id=self.database_name, **options)
def create_container_if_does_not_exists(self,
container_name=None,
partition_key_path=None,
**options):
"""
Create a container if it does not exists already
:param container_name: name of the container
:param partition_key_path: path of partition key in the data that you will commit.
eg data --> {'name': 'sajal', 'last_name': 'john'}, if 'name' is going to be your
partition key, pass partition_key_path = "/name" or "name". Partition key should be a fairly unique
value and should not be imbalanced which will create performance issues.
:param options:
:return:
"""
partition_key_path = partition_key_path or self.options_.get('partition_key_path') \
or options.get('partition_key_path')
if isinstance(partition_key_path,
str) and partition_key_path[0] != "/":
partition_key_path = "/" + partition_key_path
self.container_name = container_name if container_name else self.container_name
self.container_client = self.database_client\
.create_container_if_not_exists(
id=self.container_name,
partition_key=PartitionKey(path=partition_key_path or self.options_.get('partition_key_path')),
**options
)
def main(req: func.HttpRequest) -> func.HttpResponse:
try:
command = get_param_str(req, 'command')
if not command:
return func.HttpResponse(
'Illegal parameter: please pass in the parameter "command"',
status_code=400)
except ValueError:
return func.HttpResponse(
'Illegal parameter: the parameter "command" must be the type of string',
status_code=400)
try:
top_num = get_param_int(req, 'top_num')
except ValueError:
return func.HttpResponse(
'Illegal parameter: the parameter "top_num" must be the type of int',
status_code=400)
try:
recommend_type = get_param_int(req, 'type')
except ValueError:
return func.HttpResponse(
'Illegal parameter: the parameter "type" must be the type of int',
status_code=400)
client = CosmosClient(os.environ["CosmosDB_Endpoint"],
os.environ["CosmosDB_Key"])
database = client.create_database_if_not_exists(id="cli-recommendation")
container = database.create_container_if_not_exists(
id="recommendation-without-arguments",
partition_key=PartitionKey(path="/command"))
query = "SELECT * FROM c WHERE c.command = '{}' ".format(command)
query_items = list(
container.query_items(query=query, enable_cross_partition_query=True))
if not query_items:
return func.HttpResponse('{}', status_code=200)
result = []
for item in query_items:
if item and 'nextCommand' in item:
for command_info in item['nextCommand']:
if not recommend_type or recommend_type == command_info['type']:
command_info['ratio'] = float(
(int(command_info['count']) / int(item['totalCount'])))
result.append(command_info)
if top_num:
result = result[0:top_num]
return func.HttpResponse(generate_response(data=result, status=200))
def lambda_handler(event, context):
# Initialize the Cosmos client
# Initialize the Cosmos client
endpoint = "https://<db-account-name>.documents.azure.com:443/"
key = '<primary-key>'
# <create_cosmos_client>
client = CosmosClient(endpoint, key)
# </create_cosmos_client>
# Create a database
# <create_database_if_not_exists>
database_name = 'firstCosmosDatabase'
database = client.create_database_if_not_exists(id=database_name)
# </create_database_if_not_exists>
# Create a container
# Using a good partition key improves the performance of database operations.
# <create_container_if_not_exists>
container_name = 'firstCosmosContainer4'
container = database.create_container_if_not_exists(
id=container_name,
partition_key=PartitionKey(path="/id"),
offer_throughput=400
)
# </create_container_if_not_exists>
# Add items to the container
items_to_create_list=[]
m=0
count=0
while(m<1):
n=0
while(n<256):
#print(f'10.{m}.{n}.0/20')
count+=1
items_to_create_list.append(prepare_item(f'10.{m}.{n}.0/20'))
n+=16
m+=1
print(count)
# <create_item>
for each_item in items_to_create_list:
print(each_item)
container.create_item(body=each_item)
# </create_item>
return {
'statusCode': 200,
'body': json.dumps('Hello from Lambda!')
}
def main(req: func.HttpRequest) -> func.HttpResponse:
logging.info('Python HTTP trigger function processed a request.')
try:
req_body = req.get_json()
username = req_body['username']
code = req_body['code']
except:
return func.HttpResponse("Please pass username in the request body",
status_code=400)
try:
endpoint = "https://*****:*****@binarybeasts.com',
to_emails=email,
subject='Password Reset',
html_content=
'OTP to reset password of your QR Based Inventory account <strong>'
+ code + '</strong>')
try:
sg = SendGridAPIClient(os.environ.get('SENDGRID_API_KEY'))
response = sg.send(message)
print(response.status_code)
print(response.body)
print(response.headers)
except Exception as e:
print(e.message)
return func.HttpResponse(f"Send")
else:
return func.HttpResponse("Username not found", status_code=400)
def main(req: func.HttpRequest) -> func.HttpResponse:
"""
This Function expects an input JSON web request, and will create a new entry in the Cosmos Database
based on the input of this Function
If you haven't already, PLEASE see the 'local' version of this code in order to get a more verbose
explanation of what's going on in this Function!
"""
# Your endpoint is specific to your database, allowing you to access
# its contents over the internet!
ENDPOINT = '<ENDPOINT>'
# Your private key is your unique "password" that grabts you
# permission to modify your database, DO NOT SHARE THIS KEY!
KEY = '<KEY>'
# Initialize your CosmosDB Client, allowing you to use CosmosDB APIs
cosmos_client = CosmosClient(ENDPOINT, KEY)
# Initialize your database if it doesn't exist
database_name = 'demo_database'
cosmos_database = cosmos_client.create_database_if_not_exists(
id=database_name)
# Initialize your container inside of the database if it doesn't exist
container_name = 'demo_container'
cosmos_container = cosmos_database.create_container_if_not_exists(
id=container_name,
partition_key=PartitionKey(path='/type'),
offer_throughput=400)
# Get the JSON object you sent over the web
# Remember, the JSON object requires the 'id' field in order to work properly!
# Example of a request that will work without error:
# {
# "id": "123",
# "type": "smoothie",
# "name": "berry smoothie",
# "ingredients": ["blackberry", "strawberry"]
# }
object_to_create = req.get_json()
# Try to create the object in the database using .create_item(object)
try:
response = cosmos_container.create_item(body=object_to_create)
return func.HttpResponse(f'We made an item in the database!',
status_code=200)
# Catch any errors that might occur
except:
return func.HttpResponse(f'Something went wrong :(', status_code=400)
def __init__(self):
if TodoDatabase.__instance == None:
client = CosmosClient(ENDPOINT, KEY)
database_name = 'TodoAppDatabase'
self.database = client.create_database_if_not_exists(
id=database_name)
container_name = 'TodoAppContainer'
self.client = self.database.create_container_if_not_exists(
id=container_name,
partition_key=PartitionKey(path="/id"),
offer_throughput=400)
TodoDatabase.__instance = self
else:
logging.fatal("Cannot call constructor directly from singleton.")
def initialize():
endpoint = "<cosmos db endpoint>"
key = '<db key>'
client = CosmosClient(endpoint, key)
database_name = 'image-data'
print("database name: " + database_name)
database = client.create_database_if_not_exists(id=database_name)
container_name = 'image-analyze-data'
print("container name: " + container_name)
container = database.create_container_if_not_exists(
id=container_name,
partition_key=PartitionKey(path="/requestId"),
offer_throughput=400)
return container
def main(req: func.HttpRequest) -> func.HttpResponse:
try:
req_body = req.get_json()
Product_ID = req_body['Product-ID']
except:
return func.HttpResponse(
"Please pass Product-ID request body",
status_code=400
)
try:
endpoint = "https://localhost:8081/"
key = os.environ.get('Datakey')
client = CosmosClient(endpoint, key)
except:
return func.HttpResponse(
"Invalid Database Credentials",
status_code=400
)
try:
database_name = 'Air-Inventory'
database = client.create_database_if_not_exists(id=database_name)
container_name = 'products'
container = database.create_container_if_not_exists(
id=container_name,
partition_key=PartitionKey(path="/Type"),
offer_throughput=400
)
query = "SELECT * FROM ALL"
items = list(container.query_items(
query=query,
enable_cross_partition_query=True
))
for item in items:
if(Product_ID == item["id"]):
tem = {}
tem['Product-Name'] = item['Product-Name']
tem['Height'] = item['Height']
tem['Width'] = item['Width']
tem['Breadth'] = item['Breadth']
tem['Weight'] = item['Weight']
tem['Type'] = item['Type']
tem['order'] = ['Product-Name','Height','Width','Breadth','Weight']
out = json.dumps(tem)
break
except:
out="failed"
return func.HttpResponse(f"{out}")
def get_recommend_from_knowledge_base(command_list,
recommend_type,
error_info,
top_num=50):
commands = get_latest_cmd(command_list)
client = CosmosClient(os.environ["CosmosDB_Endpoint"],
os.environ["CosmosDB_Key"])
database = client.create_database_if_not_exists(
id=os.environ["CosmosDB_DataBase"])
knowledge_base_container = database.create_container_if_not_exists(
id=os.environ["KnowledgeBase_Container"],
partition_key=PartitionKey(path="/command"))
query = generated_query_kql(commands[-1], recommend_type, error_info)
result = []
knowledge_base_items = list(
knowledge_base_container.query_items(
query=query, enable_cross_partition_query=True))
if knowledge_base_items:
for item in knowledge_base_items:
if 'nextCommandSet' in item:
scenario = {
'scenario': item['scenario'],
'nextCommandSet': item['nextCommandSet'],
'source': RecommendationSource.KnowledgeBase,
'type': RecommendType.Scenario
}
if 'reason' in item:
scenario['reason'] = item['reason']
result.append(scenario)
if 'nextCommand' in item:
for command_info in item['nextCommand']:
command_info['source'] = RecommendationSource.KnowledgeBase
if error_info:
command_info['type'] = RecommendType.Solution
else:
command_info['type'] = RecommendType.Command
result.append(command_info)
if len(result) >= top_num:
return result[0:top_num]
return result
def updateLocation(self, serialId, location, datetime):
client = CosmosClient(self.connection, self.key)
database_name = self.databasename
database = client.create_database_if_not_exists(id=database_name)
container = database.create_container_if_not_exists(
id=self.conatinerid,
partition_key=PartitionKey(path="/deviceid"),
offer_throughput=400
)
uid = uuid.uuid4()
itemtelemetry = {
'id': str(uid),
'deviceid': serialId,
'location' : location,
'datetime':datetime
}
container.create_item(body=itemtelemetry)
class SQLObj():
def __init__(self):
self.client = CosmosClient(url=connection_key, credential=master_key)
self.db = self.client.create_database_if_not_exists(
id=CONSTANTS['COSMOS']['DATABASE'])
self.container = self.db.create_container_if_not_exists(
id=CONSTANTS['COSMOS']['CONTAINER'],
partition_key=PartitionKey(path="/_partitionKey"),
offer_throughput=400)
def get_client(self):
return self.client
def get_db(self):
return self.db
def get_container(self):
return self.container
def main(req: func.HttpRequest) -> func.HttpResponse:
# NOTE: If you don't see the first logging statement here when debugging
# in Azure then the import statements above are likely the problem.
# If you add a new import that you installed via pip locally be sure to
# add it to requirements.txt.
logging.info('MatchSubmit2019 Begins')
cosmos_uri = os.environ['CosmosURI']
cosmos_key = os.environ['CosmosKey']
client = CosmosClient(cosmos_uri, cosmos_key)
database_name = 'TrisonicsScouting'
database = client.create_database_if_not_exists(id=database_name)
container_name = 'MatchResults2019'
container = database.create_container_if_not_exists(
id=container_name,
partition_key=PartitionKey(path="/eventKey"),
offer_throughput=400)
error_found = False
error_msg = ''
try:
# A ValueError will get tossed by req.get_json() if there's no body.
req_body = req.get_json()
# Now enforce some sanity check(s) on the document before we accept it
if not 'eventKey' in req_body.keys():
error_found = True
new_msg = 'No eventKey element defined in JSON. '
error_msg += new_msg
logging.error(new_msg)
req_body['id'] = str(uuid.uuid4())
if error_found is False:
container.create_item(body=req_body)
except ValueError:
error_found = True
error_msg = 'No JSON body found'
logging.error(error_msg)
if error_found:
return func.HttpResponse(error_msg, status_code=400)
else:
return func.HttpResponse(f'Document accepted')
class InvestmentAccessorDb(investment.investmentaccessor.InvestmentAccessor):
def __init__(self):
endpoint = "https://moneysquare.documents.azure.com:443/"
key = 'weo3vRIX2wSInZ1u4CYP18W2k55p2CZdYjnCyTo1CKpVuq3f8Ebk6SqCisW2O1J6znN49AF4vTkvCMKThcYdOQ=='
self.client = CosmosClient(endpoint, key)
database_name = 'MoneySquareDatabase'
database = self.client.create_database_if_not_exists(id=database_name)
container_name = 'InvestmentContainer'
self.container = database.create_container_if_not_exists(
id=container_name,
partition_key=PartitionKey(path="/id"),
offer_throughput=400
)
super().__init__()
def getInvestments(self, user: str) -> list:
query = 'SELECT * FROM c WHERE c.user IN ("' + user + '")'
items = list(self.container.query_items(
query=query,
enable_cross_partition_query=True
))
return items
def getInvestment(self, id: str) -> dict:
query = 'SELECT * FROM c WHERE c.id IN ("' + id + '")'
items = list(self.container.query_items(
query=query,
enable_cross_partition_query=True
))
return items[0]
def addInvestment(self, investment: dict) -> dict:
self.container.create_item(body=investment)
def updateInvestment(self, investment: dict) -> dict:
read_item = self.container.read_item(item=investment['id'], partition_key=investment['id'])
for k in investment:
read_item[k] = investment[k]
return self.container.replace_item(item=read_item, body=read_item)
def deleteInvestment(self, id: str):
self.container.delete_item(item=id, partition_key=id)
def upload():
if request.method == "POST":
endpoint = request.form.get("endpoint")
key = request.form.get("key")
client = CosmosClient(endpoint, key)
database_name = request.form.get("DB_name")
database = client.create_database_if_not_exists(id=database_name)
container_name = request.form.get("Container_name")
container = database.create_container_if_not_exists(
id=container_name,
partition_key=PartitionKey(path=request.form.get("Partition_key")),
offer_throughput=400)
query = "SELECT * FROM c OFFSET 0 LIMIT " + str(
request.form.get('number'))
items = list(
container.query_items(query=query,
enable_cross_partition_query=True))
for i in range(0, len(items)):
cosmos_lst.append(items[i])
cosmos_json = json.dumps(cosmos_lst,
ensure_ascii=False,
sort_keys=False,
indent=4)
jsonfile = open("jsontemp.json", "w", encoding="utf-8")
jsonfile.truncate(0)
jsonfile.write(cosmos_json)
data = pd.read_json("jsontemp.json")
headings.clear()
values.clear()
group_list.clear()
headings_cosmos = data.columns.tolist() # list of all headings
headings.extend(headings_cosmos)
values_cosmos = data.values.tolist() # list of all values
values.extend(values_cosmos)
group_list_data = [] # list of all unique values in group
group_list.extend(group_list_data)
for i in range(1, len(headings_cosmos) - 1):
group_list.append(data[headings_cosmos[i]].unique().tolist())
return render_template('retrieve.html',
data=data,
headings=headings_cosmos,
values=values_cosmos,
group_list=group_list)
return render_template('upload.html')
