public RequestHistory SaveRequestHistory(int requestId, int requestStatusId, string username, string notes) { Request request = this.requestRepository.Get(requestId); RequestHistory rh = new RequestHistory(); rh.AdminUser = this.userTasks.GetAdminUser(username); rh.DateStatusReached = DateTime.Now; rh.Request = request; rh.RequestStatus = this.requestStatusRepository.Get(requestStatusId); rh.Notes = notes; request.AddHistory(rh); rh = this.requestHistoryRepository.Save(rh); if (string.Equals(RequestStatus.NAME_CREATED, rh.RequestStatus.RequestStatusName)) { this.luceneTasks.AddRequest(request); } else { this.luceneTasks.UpdateRequest(request); } return(rh); }
public async Task InsertHistory(RequestHistory requestHistory) { //insert successfull measuringHistory to database await sqlDataContextcs.AddAsync(requestHistory); await sqlDataContextcs.SaveChangesAsync(); }
private static void CreateRequestHistory(Request request) { var course = request.Course; var history = new RequestHistory() { RequestId = request.Id, DepartmentId = request.DepartmentId, UpdatedOn = request.UpdatedOn, UpdatedBy = request.UpdatedBy, CourseType = request.CourseType, RequestType = request.RequestType, Exception = request.Exception, ExceptionReason = request.ExceptionReason, ExceptionTotal = request.ExceptionTotal, ExceptionAnnualCount = request.ExceptionAnnualCount, ExceptionAnnualizedTotal = request.ExceptionAnnualizedTotal, CalculatedTotal = request.CalculatedTotal, AnnualizedTotal = request.AnnualizedTotal, Approved = request.Approved, ApprovedComment = request.ApprovedComment, CourseNumber = course.Number, AverageSectionsPerCourse = course.AverageSectionsPerCourse, AverageEnrollment = course.AverageEnrollment, TimesOfferedPerYear = course.TimesOfferedPerYear, }; request.History.Add(history); }
public async Task<JsonResult<ValuteHistory>> Get() { CurrencyService currencyService = new CurrencyService(); var all = currencyService.Find(x => x.InsertDate.Date == DateTime.Now.Date); RequestHistory today = null; if (all.Any()) { today = all.First(); } if (today == null) { var data = currencyService.GetDailyData(); var valuteHistory = JsonConvert.SerializeObject(data); await currencyService.AddHistory(new RequestHistory() { InsertDate = DateTime.Now, History = valuteHistory }); return Json(data); } var history = JsonConvert.DeserializeObject<ValuteHistory>(today.History); return Json(history); }
/// <summary> /// Fetches the rotten tomatoes id. /// </summary> /// <param name="item">The item.</param> /// <param name="apiKey">The API key.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns>Task.</returns> private async Task FetchRottenTomatoesId(BaseItem item, string apiKey, CancellationToken cancellationToken) { var imdbId = item.GetProviderId(MetadataProviders.Imdb); RequestHistory.Add(DateTime.UtcNow); // Have IMDB Id using (var stream = await HttpClient.Get(new HttpRequestOptions { Url = GetMovieImdbUrl(imdbId, apiKey), ResourcePool = _rottenTomatoesResourcePool, CancellationToken = cancellationToken }).ConfigureAwait(false)) { var hit = JsonSerializer.DeserializeFromStream <RTMovieSearchResult>(stream); if (!string.IsNullOrEmpty(hit.id)) { // Got a result item.CriticRatingSummary = hit.critics_consensus; var rating = float.Parse(hit.ratings.critics_score); if (rating > 0) { item.CriticRating = rating; } item.SetProviderId(MetadataProviders.RottenTomatoes, hit.id); } } }
private void ValidateRequestHistory(RequestHistory requestHistory) { Assert.Equal(2018, requestHistory.Properties.StartTime.Value.Year); Assert.Equal(10, requestHistory.Properties.StartTime.Value.Month); Assert.Equal(25, requestHistory.Properties.StartTime.Value.Day); Assert.Equal(18, requestHistory.Properties.StartTime.Value.Hour); Assert.Equal(36, requestHistory.Properties.StartTime.Value.Minute); Assert.Equal(51, requestHistory.Properties.StartTime.Value.Second); Assert.Equal(DateTimeKind.Utc, requestHistory.Properties.StartTime.Value.Kind); Assert.Equal(2018, requestHistory.Properties.EndTime.Value.Year); Assert.Equal(10, requestHistory.Properties.EndTime.Value.Month); Assert.Equal(25, requestHistory.Properties.EndTime.Value.Day); Assert.Equal(18, requestHistory.Properties.EndTime.Value.Hour); Assert.Equal(36, requestHistory.Properties.EndTime.Value.Minute); Assert.Equal(52, requestHistory.Properties.EndTime.Value.Second); Assert.Equal(DateTimeKind.Utc, requestHistory.Properties.EndTime.Value.Kind); Assert.Equal("GET", requestHistory.Properties.Request.Method); Assert.Equal("http://tempuri.org", requestHistory.Properties.Request.Uri); Assert.Equal("80244732be3648f59d2084fd979cdd56", ((JObject)requestHistory.Properties.Request.Headers)["x-ms-workflow-id"]); Assert.Equal(HttpStatusCode.Found, (HttpStatusCode)requestHistory.Properties.Response.StatusCode); Assert.Equal("http://www.bing.com/", ((JObject)requestHistory.Properties.Response.Headers)["Location"]); Assert.Equal("https://tempuri.org", requestHistory.Properties.Response.BodyLink.Uri); Assert.Equal(137, requestHistory.Properties.Response.BodyLink.ContentSize); Assert.Equal("2LOOAR8Eh2pd7AvRHXUhRg==", requestHistory.Properties.Response.BodyLink.ContentVersion); }
/// <summary> /// Fetches the async internal. /// </summary> /// <param name="item">The item.</param> /// <param name="force">if set to <c>true</c> [force].</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns>Task{System.Boolean}.</returns> private async Task FetchAsyncInternal(BaseItem item, bool force, CancellationToken cancellationToken) { BaseProviderInfo data; if (!item.ProviderData.TryGetValue(Id, out data)) { data = new BaseProviderInfo(); item.ProviderData[Id] = data; } var imdbId = item.GetProviderId(MetadataProviders.Imdb); if (string.IsNullOrEmpty(imdbId)) { data.LastRefreshStatus = ProviderRefreshStatus.Success; return; } var apiKey = GetApiKey(); if (string.IsNullOrEmpty(item.GetProviderId(MetadataProviders.RottenTomatoes))) { await FetchRottenTomatoesId(item, apiKey, cancellationToken).ConfigureAwait(false); } // If still empty we can't continue if (string.IsNullOrEmpty(item.GetProviderId(MetadataProviders.RottenTomatoes))) { data.LastRefreshStatus = ProviderRefreshStatus.Success; return; } RequestHistory.Add(DateTime.UtcNow); using (var stream = await HttpClient.Get(new HttpRequestOptions { Url = GetMovieReviewsUrl(item.GetProviderId(MetadataProviders.RottenTomatoes), apiKey), ResourcePool = _rottenTomatoesResourcePool, CancellationToken = cancellationToken }).ConfigureAwait(false)) { var result = JsonSerializer.DeserializeFromStream <RTReviewList>(stream); var criticReviews = result.reviews.Select(rtReview => new ItemReview { ReviewerName = rtReview.critic, Publisher = rtReview.publication, Date = DateTime.Parse(rtReview.date).ToUniversalTime(), Caption = rtReview.quote, Url = rtReview.links.review, Likes = string.Equals(rtReview.freshness, "fresh", StringComparison.OrdinalIgnoreCase) }).ToList(); await _itemRepo.SaveCriticReviews(item.Id, criticReviews).ConfigureAwait(false); } data.LastRefreshStatus = ProviderRefreshStatus.Success; SetLastRefreshed(item, DateTime.UtcNow); }
// // GET: /NewRequest/ public ActionResult Index() { var inputRequest = new RequestHistory(); inputRequest.StartDate = DateTime.Now; inputRequest.EndDate = DateTime.Now.AddDays(1); return View(inputRequest); }
public async Task <ActionResult> Create(RequestHistory request) { if (!await _reqHisRepo.Contains(request)) { await _reqHisRepo.AddRequestHistoryAsync(request); } return(Ok()); }
public async Task AddHistory(RequestHistory history) { using (CurrencyContext context = new CurrencyContext()) { context.RequestHistory.Add(history); await context.SaveChangesAsync(); } }
public ActionResult DeleteConfirmed(string id) { RequestHistory requestHistory = db.RequestHistories.Find(id); db.RequestHistories.Remove(requestHistory); db.SaveChanges(); return(RedirectToAction("Index")); }
public void Add(RequestHistory s) { using (var db = new ODTS_DBEntities()) { db.Entry(s).State = System.Data.Entity.EntityState.Added; db.SaveChanges(); } }
public ActionResult ModalPartialSendView(SendIncidentRequestViewModel model) { RequestHistory requestHistory = db.RequestHistories.Where(m => m.requestId == model.ID).FirstOrDefault(); Request request = db.Requests.FirstOrDefault(m => m.requestId == requestHistory.requestId); string statusState; string approvalMessage = "0"; if (model.NeedsApproval == "1") { statusState = "Waiting for approval"; if (model.ApprovalType == "0") { approvalMessage = "1"; } else { approvalMessage = User.Identity.Name; } } else { statusState = "Pending"; } string dep = request.departmentAssigned; request.departmentAssigned = model.Category; if (model.NeedsApproval != null && model.NeedsApproval != "0" && model.NeedsApproval != "1") { request.employeeAssigned = model.NeedsApproval; statusState = "In Progress"; } else { request.employeeAssigned = null; } db.SaveChanges(); RequestHistory newrequestHistory = new RequestHistory { requestId = model.ID, from = dep, to = model.Category, data = DateTime.Now, message = model.Message, approval = approvalMessage, status = statusState }; db.RequestHistories.Add(newrequestHistory); db.SaveChanges(); return(RedirectToAction("Dashboard")); }
public ActionResult Edit([Bind(Include = "Id")] RequestHistory requestHistory) { if (ModelState.IsValid) { db.Entry(requestHistory).State = EntityState.Modified; db.SaveChanges(); return(RedirectToAction("Index")); } return(View(requestHistory)); }
public async void PersistsRequestIfItDoesNotExistAlready() { var sqlite = new Mock<ISQLiteAsyncConnection>(); sqlite.Setup(s => s.Get<HttpRequest>()).Returns(Task.FromResult(new List<HttpRequest>())); var request = new HttpRequest { Method = HttpMethods.Get, Url = "http://localhost:3000/good" }; var requestHistory = new RequestHistory(sqlite.Object); await requestHistory.AddRequestAsync(request); sqlite.Verify(s => s.InsertAsync(It.IsAny<HttpRequest>()), Times.Once()); }
private async Task <ItemUpdateType> FetchAsyncInternal(BaseItem item, CancellationToken cancellationToken) { var imdbId = item.GetProviderId(MetadataProviders.Imdb); if (string.IsNullOrEmpty(imdbId)) { return(ItemUpdateType.None); } var apiKey = GetApiKey(); if (string.IsNullOrEmpty(item.GetProviderId(RottenTomatoesExternalId.KeyName))) { await FetchRottenTomatoesId(item, apiKey, cancellationToken).ConfigureAwait(false); } // If still empty we can't continue if (string.IsNullOrEmpty(item.GetProviderId(RottenTomatoesExternalId.KeyName))) { return(ItemUpdateType.None); } if (!_security.IsMBSupporter) { _logger.Warn("Downloading critic reviews from RottenTomatoes requires a supporter membership."); return(ItemUpdateType.None); } RequestHistory.Add(DateTime.UtcNow); using (var stream = await _httpClient.Get(new HttpRequestOptions { Url = GetMovieReviewsUrl(item.GetProviderId(RottenTomatoesExternalId.KeyName), apiKey), ResourcePool = _rottenTomatoesResourcePool, CancellationToken = cancellationToken }).ConfigureAwait(false)) { var result = _jsonSerializer.DeserializeFromStream <RTReviewList>(stream); var criticReviews = result.reviews.Select(rtReview => new ItemReview { ReviewerName = rtReview.critic, Publisher = rtReview.publication, Date = DateTime.Parse(rtReview.date).ToUniversalTime(), Caption = rtReview.quote, Url = rtReview.links.review, Likes = string.Equals(rtReview.freshness, "fresh", StringComparison.OrdinalIgnoreCase) }).ToList(); await _itemRepo.SaveCriticReviews(item.Id, criticReviews).ConfigureAwait(false); } return(ItemUpdateType.MetadataDownload); }
public void Trace(string shortUrl, RequestHistory requestHistory) { shortUrl = shortUrl.Split('/')[2]; var url = ShortenURlDbContext.ShortUrl.FirstOrDefault(c => c.ShortUrlString == shortUrl); if (url != null) { url.RequestHistorie.Add(requestHistory); ShortenURlDbContext.SaveChanges(); } }
public List <RequestHistory> GetRequestHistory(string studentId, ref List <string> errors) { System.Diagnostics.Debug.WriteLine("Hi FROM DEBUGGER!!!!!!!!!"); var conn = new SqlConnection(ConnectionString); var requestList = new List <RequestHistory>(); try { var adapter = new SqlDataAdapter(GetStudentRequestProcedure, conn) { SelectCommand = { CommandType = CommandType.StoredProcedure } }; adapter.SelectCommand.Parameters.Add(new SqlParameter("@student_id", SqlDbType.VarChar, 20)); adapter.SelectCommand.Parameters["@student_id"].Value = studentId; var dataSet = new DataSet(); adapter.Fill(dataSet); if (dataSet.Tables[0].Rows.Count == 0) { return(null); } for (var i = 0; i < dataSet.Tables[0].Rows.Count; i++) { var request = new RequestHistory { ScheduleId = Convert.ToInt32(dataSet.Tables[0].Rows[i]["schedule_id"].ToString()), RequestMessage = dataSet.Tables[0].Rows[i]["request"].ToString(), CourseTitle = dataSet.Tables[0].Rows[i]["course_title"].ToString(), CourseDescription = dataSet.Tables[0].Rows[i]["course_description"].ToString(), Year = dataSet.Tables[0].Rows[i]["year"].ToString(), Quarter = dataSet.Tables[0].Rows[i]["quarter"].ToString(), Session = dataSet.Tables[0].Rows[i]["session"].ToString() }; requestList.Add(request); } } catch (Exception e) { errors.Add("Error: " + e); } finally { conn.Dispose(); } return(requestList); }
public ActionResult Create([Bind(Include = "Id")] RequestHistory requestHistory) { if (ModelState.IsValid) { db.RequestHistories.Add(requestHistory); db.SaveChanges(); return(RedirectToAction("Index")); } return(View(requestHistory)); }
public async Task <SearchHistory> FileHistory(string filePath, string itemVersion) { RequestHistory req = new RequestHistory { ItemPath = filePath, ItemVersion = "T", Top = 200 }; List <KeyValuePair <string, string> > args = new List <KeyValuePair <string, string> >(); args.Add(new KeyValuePair <string, string>("searchCriteria", JsonConvert.SerializeObject(req))); return(await base._httpApiClient.PostAsync <SearchHistory>(args, TfsUrlBuilder(path + "history"), tfsSettings.Token)); }
public async void DoesNotPersistRequestIfItAlreadyExists2(HttpMethods method, string url, int times) { var request = new HttpRequest { Method = HttpMethods.Get, Url = "http://localhost:3000/good" }; var sqlite = new Mock<ISQLiteAsyncConnection>(); sqlite.Setup(s => s.Get<HttpRequest>()).Returns(Task.FromResult(new List<HttpRequest> { request })); var newRequest = new HttpRequest { Method = method, Url = url }; var requestHistory = new RequestHistory(sqlite.Object); await requestHistory.AddRequestAsync(newRequest); sqlite.Verify(s => s.InsertAsync(It.IsAny<HttpRequest>()), times.ToTimes()); }
public async void PersistsRequestIfMethodIsDifferentAndUrlIsTheSame() { var url = "http://localhost:3000/good"; var oldRequest = new HttpRequest { Method = HttpMethods.Get, Url = url }; var sqlite = new Mock<ISQLiteAsyncConnection>(); sqlite.Setup(s => s.Get<HttpRequest>()).Returns(Task.FromResult(new List<HttpRequest> { oldRequest })); var requestHistory = new RequestHistory(sqlite.Object); await requestHistory.AddRequestAsync(new HttpRequest { Method = HttpMethods.Put, Url = url }); sqlite.Verify(s => s.InsertAsync(It.IsAny<HttpRequest>()), Times.Once()); }
// GET: RequestHistories/Delete/5 public ActionResult Delete(string id) { if (id == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } RequestHistory requestHistory = db.RequestHistories.Find(id); if (requestHistory == null) { return(HttpNotFound()); } return(View(requestHistory)); }
//private readonly IAlphabetEncoder _dsa; //public HistoryPresentation() //{ // _dsa = EncoderFactory // .CreateEncoder(EncoderType.Trithemius) // .SetMonoAlphabet(Alphabet.GetMono(MonoAlphabet.UTF16)) // .Configure(79, new Func<int, int>(x => x +2)); //} public void AddHistory(RequestHistory requestHistory) { if (!HistoryHolder.HistoryCodingEntity.Any(p => p.Name.ToLower() .Equals(requestHistory?.Name?.ToLower()))) { HistoryHolder.HistoryCodingEntity.Add(new HistoryCodingEntity() { Name = requestHistory?.Name, }); } HistoryCodingEntity historyCodingEntity = HistoryHolder.HistoryCodingEntity.FirstOrDefault(p => p.Name.ToLower() .Equals(requestHistory?.Name?.ToLower())); HistoryDetailByCodingEntity historyDetailByCodingEntity = historyCodingEntity.HistoryDetailByCodingEntity .FirstOrDefault(p => p.GuidId.Equals(requestHistory.GuidId)); if (historyDetailByCodingEntity == null) { historyDetailByCodingEntity = new HistoryDetailByCodingEntity() { GuidId = requestHistory.GuidId, CodingType = requestHistory.CodingType, }; if (!historyCodingEntity.HistoryDetailByCodingEntity .Contains(historyDetailByCodingEntity)) { historyCodingEntity.HistoryDetailByCodingEntity .Add(historyDetailByCodingEntity); } } HistoryDetailByAnswerEntity historyDetailByAnswerEntity = new HistoryDetailByAnswerEntity() { Mark = requestHistory.Mark, Answer = requestHistory.Answer, DateTime = DateTime.Now, CorrectAnswer = requestHistory.CorrectAnswer }; historyDetailByCodingEntity.HistoryDetailByAnswerEntity .Add(historyDetailByAnswerEntity); Serializer(); }
public async Task <ActionResult> Create(IncidentRequestViewModel model) { if (ModelState.IsValid) { using (TehnicalDepartmentDb db = new TehnicalDepartmentDb()) { string CreatedByName = User.Identity.Name; int CreatedById = db.Users.FirstOrDefault(u => u.username == CreatedByName).userId; Request request = new Request { createdBy = CreatedById, title = model.title, description = model.description, type = model.type == "0" ? false : true, departmentAssigned = model.departmentAssigned, employeeAssigned = null, priority = model.priority }; db.Requests.Add(request); await db.SaveChangesAsync(); List <Request> newRequestList = db.Requests.Where(u => u.createdBy == CreatedById).ToList(); List <Request> newRequestListDescendingOrder = newRequestList.OrderByDescending(u => u.requestId).ToList(); int newRequestId = newRequestListDescendingOrder.First().requestId; RequestHistory requestHistory = new RequestHistory { requestId = newRequestId, from = CreatedByName, to = model.departmentAssigned, data = DateTime.Now, status = "Pending" }; db.RequestHistories.Add(requestHistory); await db.SaveChangesAsync(); return(RedirectToAction("Support")); } } // ViewBag.createdBy = new SelectList(db.Users, "userId", "company", request.createdBy); return(View(model)); }
public async Task <ServiceRequestModel> CreateServiceRequest(ServiceRequestModel serviceRequest) { var user = await _unitOfWork.UserRepository.GetByUsername(serviceRequest.Username); if (user != null) { var service = await _unitOfWork.ServiceRepository.GetByIdToModel(serviceRequest.ServiceId); serviceRequest.UserId = user.Id; serviceRequest.Status = "Waiting"; serviceRequest.DueDateTime = DateTime.Now.AddDays(service.ProcessMaxDay); var entity = _mapper.Map <ServiceRequest>(serviceRequest); await _unitOfWork.ServiceRequestRepository.Create(entity); var history = new RequestHistory { TicketId = entity.TicketId, ContentHistory = "Insert by: " + user.FullName + " - Insert Datetime: " + DateTime.Now.ToLocalTime(), UpdDatetime = DateTime.Now }; _unitOfWork.RequestHistoryRepository.Create(history); //List<string> ListFcmToken = await _unitOfWork.FcmTokenRepository.Get(user.Id); //foreach (string FcmToken in ListFcmToken) //{ // await Utils.PushNotificationAsync(FcmToken, "Create Request", "A request with ticket ID " + entity.TicketId + " has been inserted by: " + user.FullName + " - Insert Datetime: " + DateTime.Now.ToLocalTime()); //} //var noti = new Notification //{ // Title = "Create Request", // Content = "Create successful request with ticket ID " + entity.TicketId, // UserId = user.Id, // InsBy = user.Username, // UpdBy = user.Username //}; //await _unitOfWork.NotificationRepository.Create(noti); await _unitOfWork.Commit(); var modelToReturn = await _unitOfWork.ServiceRequestRepository.GetByIdToModel(entity.TicketId); return(modelToReturn); } return(null); }
public override void SaveInfo() { RequestHistory rh = new RequestHistory() { RequestHistoryId = 1, RequestId = "a", ApprovalStatus = 1, Comments = "sample", UpdatedBy = "qiaozhi.yang", }; using (var context = ApprovalRequestsDBContext.ApprovalRequestsDBContextFactory.Create(connectionString)) { context.Add(rh); context.SaveChanges(); } }
public ActionResult Assigned(int?id) { try { Request req = db.Requests.Where(m => m.requestId == id).FirstOrDefault(); RequestHistory reqHistory = db.RequestHistories.Where(m => m.requestId == id).FirstOrDefault(); req.employeeAssigned = User.Identity.Name; reqHistory.status = "In Progress"; db.SaveChanges(); return(RedirectToAction("Dashboard")); } catch { return(View()); } }
public async Task <CommentModel> CreateComment(CommentModel comment) { var user = await _unitOfWork.UserRepository.GetByUsername(comment.Username); if (user != null) { var entity = _mapper.Map <Comment>(comment); entity.UserId = user.Id; entity.InsBy = comment.Username; entity.UpdBy = comment.Username; await _unitOfWork.CommentRepository.Create(entity); var history = new RequestHistory { TicketId = entity.TicketId, ContentHistory = "A new comment is added by: " + user.FullName + " - Insert Datetime: " + DateTime.Now.ToLocalTime(), UpdDatetime = DateTime.Now.ToLocalTime(), }; _unitOfWork.RequestHistoryRepository.Create(history); ////// List <string> ListFcmToken = await _unitOfWork.FcmTokenRepository.Get(entity.UserId); foreach (string FcmToken in ListFcmToken) { await Utils.PushNotificationAsync(FcmToken, "Comment Of Request", "A new comment has been added by: " + user.FullName + " - Insert Datetime: " + DateTime.Now.ToLocalTime()); } var noti = new Notification { Title = "Comment Of Request", Content = "A comment is added by: " + user.FullName + " at " + DateTime.Now.ToLocalTime(), UserId = entity.UserId, InsBy = user.Username, UpdBy = user.Username }; await _unitOfWork.NotificationRepository.Create(noti); await _unitOfWork.Commit(); var modelToReturn = await _unitOfWork.CommentRepository.GetByIdToModel(entity.Id); return(modelToReturn); } return(null); }
protected IList <RequestPerson> GetRequestPersons(string requestPersonStatus) { RequestPerson rpAlias = null; RequestPersonHistory rphAlias = null; RequestPersonStatus rpsAlias = null; Request rAlias = null; RequestHistory rhAlias = null; RequestStatus rsAlias = null; return(Session.QueryOver <RequestPerson>(() => rpAlias) .JoinAlias(() => rpAlias.RequestPersonHistories, () => rphAlias) .JoinAlias(() => rphAlias.RequestPersonStatus, () => rpsAlias) .JoinAlias(() => rpAlias.Request, () => rAlias) .JoinAlias(() => rAlias.RequestHistories, () => rhAlias) .JoinAlias(() => rhAlias.RequestStatus, () => rsAlias) .WhereRestrictionOn(() => rsAlias.RequestStatusName) .IsIn(new string[] { RequestStatus.NAME_SENT_FOR_SCREENING, RequestStatus.NAME_SCREENING_IN_PROGRESS, RequestStatus.NAME_SENT_FOR_CONSOLIDATION }) .And(() => rpsAlias.RequestPersonStatusName == requestPersonStatus) .TransformUsing(Transformers.DistinctRootEntity) .List <RequestPerson>()); }
private void SetRequestHistory_History() { string[] retMessage = new string[4]; JavaScriptSerializer JsSerializer = new JavaScriptSerializer(); try { if (HttpContext.Current.Request.QueryString.AllKeys.Contains("RequestID")) { decimal requestID = decimal.Parse(this.StringBuilder.CreateString(HttpContext.Current.Request.QueryString["RequestID"]), CultureInfo.InvariantCulture); KartablRequestHistoryProxy kartablRequestHistoryProxy = this.KartableBusiness.GetRequestHistory(requestID); RequestHistory requestHistory = new RequestHistory(); requestHistory.IsLeave = kartablRequestHistoryProxy.IsLeave; requestHistory.From = kartablRequestHistoryProxy.From != null ? kartablRequestHistoryProxy.From : string.Empty; requestHistory.To = kartablRequestHistoryProxy.To != null ? kartablRequestHistoryProxy.To : string.Empty; requestHistory.UesedInMonth = kartablRequestHistoryProxy.UesedInMonth != null ? kartablRequestHistoryProxy.UesedInMonth : string.Empty; requestHistory.UesedInYear = kartablRequestHistoryProxy.UesedInYear != null ? kartablRequestHistoryProxy.UesedInYear : string.Empty; requestHistory.RemainLeaveInMonth = kartablRequestHistoryProxy.RemainLeaveInMonth != null ? kartablRequestHistoryProxy.RemainLeaveInMonth : string.Empty; requestHistory.RemainLeaveInYear = kartablRequestHistoryProxy.RemainLeaveInYear != null ? kartablRequestHistoryProxy.RemainLeaveInYear : string.Empty; requestHistory.Description = kartablRequestHistoryProxy.Description != null ? kartablRequestHistoryProxy.Description : string.Empty; this.hfHistory_History.Value = JsSerializer.Serialize(requestHistory); } } catch (UIValidationExceptions ex) { retMessage = this.exceptionHandler.HandleException(this.Page, ExceptionTypes.UIValidationExceptions, ex, retMessage); this.ErrorHiddenField_History.Value = JsSerializer.Serialize(retMessage); } catch (UIBaseException ex) { retMessage = this.exceptionHandler.HandleException(this.Page, ExceptionTypes.UIBaseException, ex, retMessage); this.ErrorHiddenField_History.Value = JsSerializer.Serialize(retMessage); } catch (Exception ex) { retMessage = this.exceptionHandler.HandleException(this.Page, ExceptionTypes.Exception, ex, retMessage); this.ErrorHiddenField_History.Value = JsSerializer.Serialize(retMessage); } }
protected IList <Request> GetRequests(string[] statusNames) { Request rAlias = null; RequestHistory rhAlias = null; RequestStatus rsAlias = null; var currentRequestHistoryIds = QueryOver.Of <RequestHistory>() .Where(rh => rh.Request.Id == rAlias.Id) .And(rh => !rh.Archive) .OrderBy(rh => rh.DateStatusReached).Desc .Select(rh => rh.Id) .Take(1); return(Session.QueryOver <Request>(() => rAlias) .JoinAlias(() => rAlias.RequestHistories, () => rhAlias) .JoinAlias(() => rhAlias.RequestStatus, () => rsAlias) .WhereRestrictionOn(() => rsAlias.RequestStatusName).IsIn(statusNames) .And(() => !rAlias.Archive) .WithSubquery.WhereProperty(() => rhAlias.Id).In(currentRequestHistoryIds) .OrderBy(() => rAlias.ReferenceNumber).Desc .TransformUsing(Transformers.DistinctRootEntity) .List <Request>()); }
public async Task InsertHistory(RequestHistory requestHistory) { await sqlDataContextcs.AddAsync(requestHistory); await sqlDataContextcs.SaveChangesAsync(); }
public Task InsertHistory(RequestHistory requestHistory) { throw new NotImplementedException(); }
public ActionResult Update(RequestHistory inputRequest) { return RedirectToAction("Index", "NewRequest"); }
public async void CallsOnNextWhenNewDataIsPersisted(HttpMethods method, string url, bool expectedResult) { var oldRequest = new HttpRequest(HttpMethods.Get, "http://localhost:3000/good"); var sqlite = new Mock<ISQLiteAsyncConnection>(); sqlite.Setup(s => s.Get<HttpRequest>()).Returns(Task.FromResult(new List<HttpRequest> { oldRequest })); var newRequest = new HttpRequest(method, url); var requestHistory = new RequestHistory(sqlite.Object); // if onnext is not called by the time the timeout happens, then call OnException. Observable.Timeout(requestHistory.GetRequestsObservable(), TimeSpan.FromSeconds(2)) .Subscribe( _ => Assert.True(expectedResult), ex => Assert.False(expectedResult)); await requestHistory.AddRequestAsync(newRequest); }