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);
}
