|
public static GetItemAsync ( string id ) : Task |
||
| id | string | |
| Результат | Task |
|
public async Task <IActionResult> GetAvailableTicketsAsyc(string id, string category)
{
var evt = await DocumentDBRepository <Event> .GetItemAsync(id, category);
if (evt == null)
{
return(NotFound());
}
return(Ok(new { seatsAvailable = evt.SeatsAvailable }));
}
public async Task <ActionResult> DeleteTCV(string id)
{
TechChecklist tc = await DocumentDBRepository.GetItemAsync <TechChecklist>(id);
if (tc.DbJobId == (string)Session["DbJobId"])
{
await DocumentDBRepository.DeleteItemAsync(id);
}
return(View());
}
public async Task <ActionResult> GetDetails(string id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Reservation item = await DocumentDBRepository <Reservation> .GetItemAsync(id);
if (item == null)
{
return(HttpNotFound());
}
if (item.EndReservationDate.HasValue == false)
{
double clientStayingTime = Math.Sqrt(Convert.ToInt64(item.NrOfPersons));
clientStayingTime = Convert.ToInt32(clientStayingTime);
var hours = Convert.ToInt32(clientStayingTime);
if (hours + item.Date.Value.Hour > 24)
{
item.EndReservationDate = new DateTime(item.Date.Value.Year,
item.Date.Value.Month,
item.Date.Value.Day,
Math.Abs(24 - hours),
item.Date.Value.Minute,
item.Date.Value.Second);
item.EndReservationDate.Value.AddDays(1);
}
else if (hours + item.Date.Value.Hour < 24)
{
item.EndReservationDate = new DateTime(item.Date.Value.Year,
item.Date.Value.Month,
item.Date.Value.Day,
item.Date.Value.Hour + hours,
item.Date.Value.Minute,
item.Date.Value.Second);
}
else if (hours + item.Date.Value.Hour == 24)
{
item.EndReservationDate = new DateTime(item.Date.Value.Year,
item.Date.Value.Month,
item.Date.Value.Day,
0,
item.Date.Value.Minute,
item.Date.Value.Second);
item.EndReservationDate.Value.AddDays(1);
}
}
return(View(item));
}
public async Task <ActionResult> EditAsync(IORA item)
{
if (ModelState.IsValid)
{
await DocumentDBRepository.UpdateItemAsync <IORA>(item.Id, item);
IORA ii = item;
Job j = await DocumentDBRepository.GetItemAsync <Job>(ii.DbJobId);
if (!string.IsNullOrEmpty(item.IORASentBy))
{
j.IoraSentTime = ii.IORASentTime;
j.Task2 = "Y";
await DocumentDBRepository.UpdateItemAsync <Job>(j.Id, j);
}
else
{
j.IoraSentTime = null;
j.Task2 = "TASK";
await DocumentDBRepository.UpdateItemAsync <Job>(j.Id, j);
}
ViewBag.Job = j;
ViewBag.BIORA = await DocumentDBRepository.GetItemsAsync <BIORA>(d => d.Tag == "BIORA" && d.BridgeModule == ii.BridgeModule);
ViewBag.Rules = await DocumentDBRepository.GetItemsAsync <Rule>(d => d.Tag == "Rule" && d.DbJobId == ii.DbJobId);
var f = await DocumentDBRepository.GetItemsAsync <BFinancial>(d => d.Tag == "BFinancial" && d.BridgeModule == ii.BridgeModule && d.CertType == j.CertType);
ViewBag.FinancialSet = f.FirstOrDefault();
ViewBag.LUser = await DocumentDBRepository.GetItemsAsync <BUser>(d => d.Tag == "BUser" && (d.BridgesGranted).Contains(j.BridgeModule));
//await DocumentDBRepository.UpdateItemAsync<Job>(item.Id, item);
if (!string.IsNullOrEmpty(item.SendingFlag) && item.SendingFlag != "-")
{
Session["SendingFlag"] = item.SendingFlag;
j.TaskHandler = ii.TaskHandler;
j.GetType().GetProperty("Task" + item.SendingFlag).SetValue(j, "TASK", null);
await DocumentDBRepository.UpdateItemAsync <Job>(j.Id, j);
return(Redirect(Url.Content("~/Job/SendJob/" + item.DbJobId)));
}
else
{
return(View(item));
}
}
else
{
return(View(item));
}
}
public async Task <ActionResult> Email([Bind(Include = "Password,Recipient,Name")] Email email, string id)
{
if (ModelState.IsValid)
{
Students student = await DocumentDBRepository <Students> .GetItemAsync(id);
email.SendEmail(student);
return(View("Details", student));
}
return(View("Search"));
}
public async Task <ActionResult> InputApprOrderIdPost(string id, string apprOrderId)
{
Job j = await DocumentDBRepository.GetItemAsync <Job>(id);
if (!string.IsNullOrEmpty(apprOrderId) && apprOrderId.Length > 7)
{
j.SubOrderNo = apprOrderId;
await DocumentDBRepository.UpdateItemAsync <Job>(j.Id, j);
}
return(Redirect(Url.Content("~/Job/NCertReporting/" + j.Id)));
}
public async Task <string> ChangeJobVerifier(string id, string newJobHandler)
{
Job j = await DocumentDBRepository.GetItemAsync <Job>(id);
if (j != null)
{
j.JobVerifier = newJobHandler;
await DocumentDBRepository.UpdateItemAsync <Job>(j.Id, j);
}
return("OK");
}
public async Task <ActionResult> CreateAsync()
{
var j = await DocumentDBRepository <Job> .GetItemAsync("a74571b7-2758-48ae-bd1a-d88efc437f26");
ViewBag.Job = j;
//var f = await DocumentDBRepository<BingFinancial>.GetItemsAsync(d => d.Tag == "BingFinancial" && d.BridgeModule == j.BridgeModule && d.CertType == j.CertType);
//ViewBag.FinancialSet = f.FirstOrDefault();
var S = new BingLSACert();
return(View(S));
}
public async Task <ActionResult> DeleteConfirmedAsync([Bind(Include = "StudentID")] string id)
{
Student item = await DocumentDBRepository <Student> .GetItemAsync(id);
if (item.ImageUrl != null)
{
BlobManager BlobManagerObj = new BlobManager("picture");
BlobManagerObj.DeleteBlob(item.ImageUrl);
}
await DocumentDBRepository <Student> .DeleteItemAsync(id);
return(RedirectToAction("Index"));
}
public async System.Threading.Tasks.Task <ActionResult> SaveCustomerAsync(string id, string contactPerson, string phoneNo, string email, string invoiceInfo)
{
Customer c = await DocumentDBRepository.GetItemAsync <Customer>(id);
c.ContactPerson = contactPerson;
c.PhoneNo = phoneNo;
c.Email = email;
c.InvoiceInfo = invoiceInfo;
c.Email = email;
await DocumentDBRepository.UpdateItemAsync <Customer>(c.Id, c);
return(View());
}
public async Task <string> UpdateTCAPI(string tcID = "", Boolean tcOKValue = true, Boolean tcNAValue = true)
{
if (!string.IsNullOrEmpty(tcID))
{
TechChecklist tc = await DocumentDBRepository.GetItemAsync <TechChecklist>(tcID);
tc.TCNA = tcNAValue;
tc.TCOK = tcOKValue;
await DocumentDBRepository.UpdateItemAsync <TechChecklist>(tc.Id, tc);
}
return("done");
}
public async Task <string> SaveBTCItem(string itemId, string Subject, string SubProdType, string GudianceNote, string RuleRef, string Condition)
{
BTechChecklist btc = await DocumentDBRepository.GetItemAsync <BTechChecklist>(itemId);
btc.Subject = Subject;
btc.SubProdType = SubProdType;
btc.GudianceNote = GudianceNote;
btc.RuleRef = RuleRef;
btc.Condition = Condition;
await DocumentDBRepository.UpdateItemAsync <BTechChecklist>(btc.Id, btc);
return("Saved");
}
public async Task <ActionResult> DetailsAsync(string id, string student_no)
{
Item item = await DocumentDBRepository <Item> .GetItemAsync(id, student_no);
if (item.Photo_Path != null)
{
ViewBag.Image = "True";
}
else
{
ViewBag.Image = "False";
}
return(View(item));
}
// GET: Employees/Delete/5
public async Task <ActionResult> Delete(string id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Employee employee = await DocumentDBRepository <Employee> .GetItemAsync(id);
if (employee == null)
{
return(HttpNotFound());
}
return(View(employee));
}
public static async Task <HttpResponseMessage> Get(
[HttpTrigger(AuthorizationLevel.Function, "get", Route = "users/{id}")] HttpRequest req,
String id,
ExecutionContext context,
ILogger log)
{
init(context);
log.LogInformation("id: " + id);
User user = await DocumentDBRepository <User> .GetItemAsync(id);
return(Responses.Success(JsonConvert.SerializeObject(user)));
}
public async Task DocumentDBRepositoryTest_GetItemAsync_ReturnsItem()
{
var mockDocumentClient = Substitute.For <IDocumentClient>();
var mockCosmosClient = Substitute.For <ICosmosClient>();
mockDocumentClient.ReadDatabaseAsync(Arg.Any <string>())
.ReturnsNull();
mockCosmosClient.ReadDocumentAsync(Arg.Any <string>())
.Returns(Task.FromResult(new Document()));
var documentDBRepository = new DocumentDBRepository <Book>(mockCosmosClient, mockDocumentClient);
var document = await documentDBRepository.GetItemAsync("1");
document.Should().NotBeNull();
}
public async Task <ActionResult> Whiteboard(string wbTab = "wb_dist")
{
var bm = (string)Session["BridgeModule"];
if (!string.IsNullOrEmpty(wbTab) && wbTab.Contains(","))
{
List <string> ls = wbTab.Split(',').ToList <string>();
Job j = await DocumentDBRepository.GetItemAsync <Job>(ls[0]);
j.TaskHandler = ls[1];
await DocumentDBRepository.UpdateItemAsync <Job>(j.Id, j);
}
var myModel = await DocumentDBRepository.GetItemsAsync <Job>(d => d.Tag == "Job" && d.BridgeModule == bm && d.IsComplete == false && (d.RAE + "x") != "x");
switch (wbTab)
{
case "wb_dist":
myModel = myModel.Where(d => d.RAE == "WHITEBOARD");
break;
case "wb_v":
myModel = myModel.Where(d => !string.IsNullOrEmpty(d.JobVerifier) && d.JobVerifier != "WHITEBOARD");
break;
case "wb_oh":
myModel = myModel.Where(d => d.IsHold == true);
break;
case "wb_og":
myModel = myModel.Where(d => d.RAE != "WHITEBOARD" && (string.IsNullOrEmpty(d.JobVerifier) || d.JobVerifier == "WHITEBOARD") && d.IsHold == false);
//myModel = myModel.Where(d => d.IsHold == false && d.Task4 == "TASK");
break;
case "wb_done":
myModel = myModel.Where(d => d.IsComplete == true && d.JobCompletedTime > DateTime.Today.AddDays(-7));
break;
default:
myModel = myModel.Where(d => d.RAE == "WHITEBOARD");
break;
}
ViewBag.WBT = wbTab;
await SetViewBags();
return(View(myModel));
}
public async Task <ActionResult> Edit(string id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Movie movie = await DocumentDBRepository <Movie> .GetItemAsync(id);
if (movie == null)
{
return(HttpNotFound());
}
return(View(movie));
}
public async Task DocumentDBRepositoryTest_GetItemAsync_ReturnsItem()
{
IDocumentClient documentClient = new DocumentClient(new Uri(_endPoint), _key);
var cosmosClient = new CosmosClient(documentClient);
var documentDBRepository = new DocumentDBRepository <Book>(cosmosClient, documentClient);
var document = await documentDBRepository.CreateItemAsync(new Book());
var documentReturned = await documentDBRepository.GetItemAsync(document.Id);
documentReturned.Id.Should().Equals(document.Id);
await documentDBRepository.DeleteItemAsync(document.Id);
documentReturned.Should().NotBeNull();
}
public async Task <ActionResult> DetailsAsync(string id)
{
Item item = await DocumentDBRepository <Item> .GetItemAsync(id);
var auditList = await this.auditReadClient.GetAuditItemsListAsync(
typeof(Item).Name, id, 100, string.Empty);
await this.auditClient.AuditAsync(
AuditRequest.AsViewOf(item, i => i.Id)
.AsEvent("ViewedItemDetail")
.WithData(item, i => i.Id)
.WithDescription("Viewed item detail"));
return(View(new ItemDetail(item, auditList)));
}
public async Task <IActionResult> ConnectPen()
{
_penConnector.connectPen();
_penConnector.ClearImage();
ViewBag.Title = "Connecting...";
var id = Request.Path.ToString().Substring(Request.Path.ToString().LastIndexOf('/') + 1);
AdminViewModel model = await DocumentDBRepository <AdminViewModel> .GetItemAsync(id);
ViewBag.pdfURL = GetBlobSasUri(model.DocGuid);
ViewBag.DocName = model.DocName;
ViewBag.Id = model.Id;
return(View("Client"));
//return new EmptyResult();
}
public async Task <ActionResult> CreateAsync()
{
var j = await DocumentDBRepository <Job> .GetItemAsync("a74571b7-2758-48ae-bd1a-d88efc437f26");
ViewBag.Job = j;
var i = await DocumentDBRepository <IORA> .GetItemAsync("290c5999-2076-46f1-b40f-443f42cea4f8");
ViewBag.IORA = i;
var f = await DocumentDBRepository <BingFinancial> .GetItemsAsync(d => d.Tag == "BingFinancial" && d.BridgeModule == j.BridgeModule && d.CertType == j.CertType);
ViewBag.FinancialSet = f.FirstOrDefault();
var S = new BingIORA();
return(View(S));
}
private static async Task <string> GetManagerId(Employee employee)
{
var managerId = employee.ManagerEmailId ?? employee.DemoManagerEmailId;
var manager = await DocumentDBRepository.GetItemAsync <Employee>(managerId);
if (manager != null)
{
return(manager.UserUniqueId);
}
else
{
return(null);
}
}
public async Task <ActionResult> DeleteAsync(string id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Student student = await DocumentDBRepository <Student> .GetItemAsync(id);
if (student == null)
{
return(HttpNotFound());
}
return(View(student));
}
public async Task TestEditItemsAsync()
{
var item = new Item
{
Id = "942b1512-1d1e-4c8a-8199-878bdc0395d8",
Student_Number = "21833736",
First_Name = "Akhie",
Last_Name = "Ishwarlaal",
Email = "*****@*****.**",
Home_Address = "Suncoast",
Mobile = "0767619968",
Photo_Path = "http...................",
Status = true
};
await DocumentDBRepository <Item> .CreateItemAsync(item);
var edititem = new Item
{
Id = "942b1512-1d1e-4c8a-8199-878bdc0395d8",
Student_Number = "21833736",
First_Name = "Akhil",
Last_Name = "Ishwarlaal",
Email = "*****@*****.**",
Home_Address = "Suncoast",
Mobile = "0767619968",
Photo_Path = "http...................",
Status = true
};
// Create the item
// update the item
await DocumentDBRepository <Item> .UpdateItemAsync(item.Id, edititem);
// Query for the item
var returnedItem = await DocumentDBRepository <Item> .GetItemAsync(item.Id, item.Student_Number);
// Verify the item returned is correct.
Assert.AreEqual(edititem.Id, returnedItem.Id);
Assert.AreEqual(edititem.Student_Number, returnedItem.Student_Number);
Assert.AreEqual(edititem.First_Name, returnedItem.First_Name);
Assert.AreEqual(edititem.Last_Name, returnedItem.Last_Name);
Assert.AreEqual(edititem.Email, returnedItem.Email);
Assert.AreEqual(edititem.Home_Address, returnedItem.Home_Address);
Assert.AreEqual(edititem.Mobile, returnedItem.Mobile);
Assert.AreEqual(edititem.Photo_Path, returnedItem.Photo_Path);
Assert.AreEqual(edititem.Status, returnedItem.Status);
}
public async Task <ActionResult> DeleteAsync(string id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
WebsiteProperties item = await DocumentDBRepository <WebsiteProperties> .GetItemAsync(id);
if (item == null)
{
return(HttpNotFound());
}
return(View(item));
}
public async Task <ActionResult> EditAsync(string id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Item item = await DocumentDBRepository <Item> .GetItemAsync(id);
if (item == null)
{
return(HttpNotFound());
}
return(View(item));
}
public async Task <ActionResult> DeleteAsync(string id)
{
if (id == null)
{
return(BadRequest());
}
LogItem item = await DocumentDBRepository <LogItem> .GetItemAsync(id);
if (item == null)
{
return(NotFound());
}
return(View(item));
}
public async Task <ActionResult> Delete(string id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
DocReq r = await DocumentDBRepository.GetItemAsync <DocReq>(id);
if (r == null)
{
return(HttpNotFound());
}
return(View(r));
}
public async Task <IActionResult> Details(string id, string search = "*", int top = 10, int skip = 0, string orderby = "date")
{
if (id == null)
{
return(StatusCode(StatusCodes.Status400BadRequest));
}
SpielEntry s = await DocumentDBRepository <SpielEntry> .GetItemAsync(id);
ViewData["SearchTop"] = top;
ViewData["SearchSkip"] = skip;
ViewData["SearchString"] = search;
ViewData["searchOrder"] = orderby;
return(View(s));
}
