public async Task <HttpResponseMessage> UnassignVacancy(HttpRequestMessage request, int candidateId, int vacancyId) { try { var userId = ContextParser.GetUserId(request.GetRequestContext()); var e = await eventService.RegisterCandidateFromVacancyUnassignment(vacancyId, candidateId, userId); var updatedCandidate = await candidateService.UnassignVacancy(candidateId, vacancyId, userId); unitOfWork.Save(); var notification = await notificationService.CreateNotification(updatedCandidate.HRM, NotificationTypes.Update, new List <Event> { e }); if (NotificationsHub.IsConnected(updatedCandidate.HRM)) { await NotificationsHub.PushNotification(notification); } unitOfWork.Save(); return(request.CreateResponse(HttpStatusCode.OK)); } catch (Exception ex) { logger.Error(ex, JsonConvert.SerializeObject(new { candidateId, vacancyId })); return(request.CreateResponse(HttpStatusCode.InternalServerError)); } }
public void ParseContext() { string contextFile = @"..\..\..\Tracker.Core\TrackerContext.Generated.cs"; var result = ContextParser.Parse(contextFile); Assert.IsNotNull(result); }
public async Task <HttpResponseMessage> AddCandidate(HttpRequestMessage request, [FromBody] CandidateInputDTO value) { try { var userId = ContextParser.GetUserId(request.GetRequestContext()); var candidate = Mapper.Map <CandidateInputDTO, Candidate>(value); candidate.HRM = userId; candidate.LastModifier = userId; var createdCandidate = await candidateService.Add(candidate, value.VacanciesIds) .ConfigureAwait(false); await eventService.RegisterCandidate(createdCandidate, userId); unitOfWork.Save(); var candidateElastic = Mapper.Map <Candidate, CandidateElasticModel>(createdCandidate); await candidateElasticService.AddCandidateElastic(candidateElastic).ConfigureAwait(false); return(request.CreateResponse(HttpStatusCode.OK, createdCandidate.Id)); } catch (Exception ex) { logger.Error(ex, JsonConvert.SerializeObject(value)); return(request.CreateResponse(HttpStatusCode.InternalServerError)); } }
public DataServiceGen( DbContext dbContext, string projectPath, string projectName, JsonPropertyFormatEnum vmPropStyle, DIContainer dIContainer, bool activeCol = true, bool requestScope = false ) { ProjectPath = projectPath; if (ProjectPath[ProjectPath.Length - 1] == '\\' || ProjectPath[ProjectPath.Length - 1] == '/') { ProjectPath = ProjectPath.Remove(ProjectPath.Length - 1); } ProjectPath += "/"; OutputPath = ProjectPath; var curDir = Directory.GetCurrentDirectory() + '/'; this.Style = vmPropStyle; ProjectName = projectName; Data = new ContextParser(dbContext, projectName).Data; Data.DIContainer = dIContainer; Data.RequestScope = requestScope; Data.ActiveCol = activeCol; }
/// <summary> /// Takes a given child element (aChildElement) and parent constraint (aParentTemplateConstraint) and steps through the Children of the parent constraint /// to determine if any siblings of the child element exist. /// </summary> /// <param name="aChildElement">Target element that we need to locate siblings for</param> /// <param name="aParentTemplateConstraint">Parent Constraint of the aChildElement</param> /// <param name="aParentElement">Parent Element for the aChildElement</param> /// <param name="aAddedConstraints">Constraints that have already been added to the child collection, we don't need to parse these.</param> static private void AddSiblingElements(DocumentTemplateElement aChildElement, IConstraint aParentTemplateConstraint, DocumentTemplateElement aParentElement, Dictionary <DocumentTemplateElement, IConstraint> aConstraintMap) { //look at parent to get the siblings if (aParentTemplateConstraint.Children != null) { DocumentTemplateElement parsedElement = null; DocumentTemplateElementAttribute parsedAttribute = null; //walk through the siblings foreach (var sibling in aParentTemplateConstraint.Children) { //have we already added this constraint in a previous iteration (e.g. it's on the main path from the leaf to the root) if (sibling.IsBranchIdentifier && !aConstraintMap.ContainsValue(sibling)) { //parse the context var cp = new ContextParser(sibling.Context); cp.Parse(out parsedElement, out parsedAttribute); //is this an element or an attribute? if ((parsedElement != null) && (!string.IsNullOrEmpty(parsedElement.ElementName))) { parsedElement.IsBranchIdentifier = sibling.IsBranchIdentifier; parsedElement.IsBranch = sibling.IsBranch; //element, let's add it to the parent element's children so it becomes a sibling of aChildElement parsedElement.Value = sibling.Value; aParentElement.AddElement(parsedElement); AddBranchedAttributes(parsedElement, sibling); aConstraintMap.Add(parsedElement, sibling); } } } } }
public async Task <HttpResponseMessage> Add(HttpRequestMessage request, [FromBody] VacancyInputDTO value) { try { var userId = ContextParser.GetUserId(request.GetRequestContext()); var vacancy = Mapper.Map <VacancyInputDTO, Vacancy>(value); var createdVacancy = await vacancyService.Post(vacancy, value.Candidates, userId) .ConfigureAwait(false); await eventService.RegisterVacancy(createdVacancy, userId); unitOfWork.Save(); var elasticVacancy = Mapper.Map <Vacancy, VacancyElasticModel>(createdVacancy); await vacancyElasticService.AddVacancyElastic(elasticVacancy); return(request.CreateResponse(HttpStatusCode.OK, createdVacancy.Id)); } catch (Exception ex) { logger.Error(ex, JsonConvert.SerializeObject(value)); return(request.CreateResponse(HttpStatusCode.InternalServerError)); } }
public async Task <HttpResponseMessage> UpdateStatus(HttpRequestMessage request, [FromBody] StatusUpdateInDTO value) { try { var userId = ContextParser.GetUserId(request.GetRequestContext()); var e = await eventService.RegisterCandidateStatusUpdate(value.EntityId, value.Status, userId); var candidate = await candidateService.UpdateStatus(value.EntityId, value.Status, userId); unitOfWork.Save(); await candidateElasticService.UpdateStatusElastic(value.EntityId, value.Status).ConfigureAwait(false); var notification = await notificationService.CreateNotification(candidate.HRM, NotificationTypes.Update, new List <Event> { e }); if (NotificationsHub.IsConnected(candidate.HRM)) { await NotificationsHub.PushNotification(notification); } return(request.CreateResponse(HttpStatusCode.OK)); } catch (Exception ex) { logger.Error(ex, JsonConvert.SerializeObject(value)); return(request.CreateResponse(HttpStatusCode.InternalServerError)); } }
public async Task <HttpResponseMessage> AssignVacancies(HttpRequestMessage request, CandidatesVacanciesInDTO value) { try { var userId = ContextParser.GetUserId(request.GetRequestContext()); var result = await candidateService.AssignVacancies(value.Vacancies, value.Candidates, userId); unitOfWork.Save(); foreach (var item in result.Events) { var notification = await notificationService.CreateNotification(item.Key, NotificationTypes.Update, item.Value); if (NotificationsHub.IsConnected(item.Key)) { await NotificationsHub.PushNotification(notification); } } unitOfWork.Save(); return(request.CreateResponse(HttpStatusCode.OK)); } catch (Exception ex) { logger.Error(ex, JsonConvert.SerializeObject(value)); return(request.CreateResponse(HttpStatusCode.InternalServerError)); } }
public void ParseCodeIdentity() { var parser = new ContextParser(NullLoggerFactory.Instance); var sb = new StringBuilder(); sb.AppendLine(@"using System;"); sb.AppendLine(@"using Microsoft.EntityFrameworkCore;"); sb.AppendLine(@"using Microsoft.EntityFrameworkCore.Metadata;"); sb.AppendLine(@""); sb.AppendLine(@"namespace Tracker.Data"); sb.AppendLine(@"{"); sb.AppendLine(@" public partial class TrackerContext : IdentityDbContext<User, Role, Guid, UserClaim, UserRole, UserLogin, RoleClaim, UserToken>"); sb.AppendLine(@" {"); sb.AppendLine(@" public TrackerContext(DbContextOptions<TrackerContext> options)"); sb.AppendLine(@" : base(options)"); sb.AppendLine(@" {"); sb.AppendLine(@" }"); sb.AppendLine(@""); sb.AppendLine(@" #region Generated Properties"); sb.AppendLine(@" public virtual DbSet<Tracker.Data.Entities.Audit> Audits { get; set; }"); sb.AppendLine(@" public virtual DbSet<Tracker.Data.Entities.Priority> Priorities { get; set; }"); sb.AppendLine(@" public virtual DbSet<Tracker.Data.Entities.Role> Roles { get; set; }"); sb.AppendLine(@" public virtual DbSet<Tracker.Data.Entities.Status> Statuses { get; set; }"); sb.AppendLine(@" public virtual DbSet<Tracker.Data.Entities.Task> Tasks { get; set; }"); sb.AppendLine(@" public virtual DbSet<Tracker.Data.Entities.User> Users { get; set; }"); sb.AppendLine(@" public virtual DbSet<Tracker.Data.Entities.TaskExtended> TaskExtended { get; set; }"); sb.AppendLine(@" public virtual DbSet<Tracker.Data.Entities.UserLogin> UserLogins { get; set; }"); sb.AppendLine(@" public virtual DbSet<Tracker.Data.Entities.UserRole> UserRoles { get; set; }"); sb.AppendLine(@" #endregion"); sb.AppendLine(@""); sb.AppendLine(@" protected override void OnModelCreating(ModelBuilder modelBuilder)"); sb.AppendLine(@" {"); sb.AppendLine(@" #region Generated Configuration"); sb.AppendLine(@" modelBuilder.ApplyConfiguration(new Tracker.Data.Mapping.AuditMap());"); sb.AppendLine(@" modelBuilder.ApplyConfiguration(new Tracker.Data.Mapping.PriorityMap());"); sb.AppendLine(@" modelBuilder.ApplyConfiguration(new Tracker.Data.Mapping.RoleMap());"); sb.AppendLine(@" modelBuilder.ApplyConfiguration(new Tracker.Data.Mapping.StatusMap());"); sb.AppendLine(@" modelBuilder.ApplyConfiguration(new Tracker.Data.Mapping.TaskMap());"); sb.AppendLine(@" modelBuilder.ApplyConfiguration(new Tracker.Data.Mapping.UserMap());"); sb.AppendLine(@" modelBuilder.ApplyConfiguration(new Tracker.Data.Mapping.TaskExtendedMap());"); sb.AppendLine(@" modelBuilder.ApplyConfiguration(new Tracker.Data.Mapping.UserLoginMap());"); sb.AppendLine(@" modelBuilder.ApplyConfiguration(new Tracker.Data.Mapping.UserRoleMap());"); sb.AppendLine(@" #endregion"); sb.AppendLine(@" }"); sb.AppendLine(@" }"); sb.AppendLine(@"}"); var result = parser.ParseCode(sb.ToString()); result.Should().NotBeNull(); result.Properties.Count.Should().Be(9); result.ContextClass.Should().Be("TrackerContext"); }
/// <summary> /// Uses back-tracing algorithm to go backwards through the tree /// Helper function which builds the full parent context for a given template constraint. For example, for the template constraint @code with cda:entryRelationship/cda:observation/cda:code[@code] /// this function returns the cda:entryRelationship/cda:observation/cda:code. /// </summary> /// <param name="aElement">current element to start from</param> /// <param name="aTemplateConstraint">constraint which will have its parent chain walked to form path</param> /// <param name="aIncludeElementInPath">determines whether we start the path with the element passed in (true) or its parent (false)</param> /// <returns>full context string</returns> public static string CreateFullParentContext(string aPrefix, IConstraint aTemplateConstraint) { if (aTemplateConstraint == null) { return(string.Empty); } DocumentTemplateElement firstElement = null; DocumentTemplateElement newElement = null; DocumentTemplateElement previousElement = null; DocumentTemplateElementAttribute newAttribute = null; IConstraint currentConstraint = aTemplateConstraint.Parent; while (currentConstraint != null) { //parse the context to determine whether this is element or attribute var contextParser = new ContextParser(currentConstraint.Context); contextParser.Parse(out newElement, out newAttribute); newElement.Attributes.Clear(); if (currentConstraint.IsBranch) //if we hit a branch then we stop b/c we are in the branch's context { break; } if (newElement == null) { break; //there is a broken chain, we have null parent } //add value and data type (if present) ConstraintToDocumentElementHelper.AddElementValueAndDataType(aPrefix, newElement, currentConstraint); //chain the previous element to the child collection of this new one if (previousElement != null) { newElement.AddElement(previousElement); } //get the leaf node if (firstElement == null) { firstElement = newElement; } previousElement = newElement; //walk the parent chain currentConstraint = currentConstraint.Parent; } if (firstElement == null) { return(string.Empty); } else { var contextBuilder = new ContextBuilder(firstElement, aPrefix); return(contextBuilder.GetFullyQualifiedContextString()); } }
public void ParseElementAndAttribute() { string context = "code/@code"; DocumentTemplateElement element = null; DocumentTemplateElementAttribute attribute = null; var parser = new ContextParser(context); parser.Parse(out element, out attribute); Assert.IsNotNull(element, "No element was passed back from the parser."); Assert.IsTrue(element.ElementName == "code", "Element name was incorrect. Expected 'code', Actual '{0}'", element.ElementName); Assert.IsNotNull(attribute, "No attribute was passed back from the parser."); Assert.IsTrue(attribute.AttributeName == "code", "Element name was incorrect. Expected 'code', Actual '{0}'", attribute.AttributeName); }
public void ParseMultipleElements() { string context = "entry/observation"; DocumentTemplateElement element = null; DocumentTemplateElementAttribute attribute = null; var parser = new ContextParser(context); parser.Parse(out element, out attribute); Assert.IsNotNull(element, "No element was passed back from the parser."); Assert.IsTrue(element.ElementName == "observation", "Element name was incorrect. Expected 'observation', Actual '{0}'", element.ElementName); Assert.IsNotNull(element.ParentElement, "No parent element was passed back from the parser."); Assert.IsTrue(element.ParentElement.ElementName == "entry", "Element name was incorrect. Expected 'entry', Actual '{0}'", element.ElementName); Assert.IsNull(attribute, "An attribute was passed back from the parser. Exected null."); }
public void ParseNonContextFile() { var parser = new ContextParser(NullLoggerFactory.Instance); var sb = new StringBuilder(); sb.AppendLine(@"namespace InstructorIQ.Core.Options"); sb.AppendLine(@"{"); sb.AppendLine(@" public class HostingConfiguration : Options<User>"); sb.AppendLine(@" {"); sb.AppendLine(@" public string Version { get; set; }"); sb.AppendLine(@" }"); sb.AppendLine(@"}"); var result = parser.ParseCode(sb.ToString()); result.Should().BeNull(); }
public async Task <HttpResponseMessage> MarkAsRead(HttpRequestMessage request, List <int> ids) { try { var userId = ContextParser.GetUserId(request.GetRequestContext()); await notificationService.MarkAsRead(userId, ids); unitOfWork.Save(); return(request.CreateResponse(HttpStatusCode.OK)); } catch (Exception ex) { logger.Error(ex, JsonConvert.SerializeObject(ids)); return(request.CreateResponse(HttpStatusCode.InternalServerError)); } }
static void Main(string[] args) { var connectionString = "Data Source=CO-YAR-WS208;Initial Catalog=OnlineShop;Integrated Security=True;MultipleActiveResultSets=True;Application Name=EntityFramework"; var currentTable = "dbo.Orders"; var userTable = "dbo.Employees"; var rowIdentifierKeys = "[id][1][int]"; var userIdentifierKeys = "[id][1][int]"; var expressions = "12.4 / 2 = 1.24"; //ContextParser.ConnectionString = connectionString; //var result1 = ContextParser.ExecuteStaticPredicate(expressions, 1, true, 1, "fdfd", DateTime.Now, DateTimeOffset.MinValue, TimeSpan.MinValue, new Guid(), // 1, true, 1, "fdfd", DateTime.Now, DateTimeOffset.MinValue, TimeSpan.MinValue, new Guid()); var result = ContextParser.ExecutePredicate(currentTable, userTable, expressions, rowIdentifierKeys, userIdentifierKeys); Console.WriteLine(result); Console.ReadKey(); }
public async Task <HttpResponseMessage> AddGeneralInterview(HttpRequestMessage request, [FromBody] GeneralInterviewInDTO value) { try { var userId = ContextParser.GetUserId(request.GetRequestContext()); var interview = Mapper.Map <GeneralInterviewInDTO, GeneralInterview>(value); interview.HRM = userId; var createdInterview = await interviewService.AddGeneralInterview(interview); var e = await eventService.RegisterGeneralInterview(createdInterview, userId); unitOfWork.Save(); if (createdInterview.Interviewer.HasValue) { var notification = await notificationService.CreateNotification(createdInterview.Interviewer.Value, NotificationTypes.Interview, new List <Event> { e }); if (NotificationsHub.IsConnected(createdInterview.Interviewer.Value)) { await NotificationsHub.PushNotification(notification); } } unitOfWork.Save(); return(request.CreateResponse(HttpStatusCode.OK)); } catch (Exception ex) { logger.Error(ex, JsonConvert.SerializeObject(value)); return(request.CreateResponse(HttpStatusCode.InternalServerError)); } }
public async Task <HttpResponseMessage> Update(HttpRequestMessage request, [FromBody] CandidateInputDTO value) { try { var userId = ContextParser.GetUserId(request.GetRequestContext()); var candidate = Mapper.Map <CandidateInputDTO, Candidate>(value); candidate.LastModifier = userId; var events = await eventService.RegisterCandidateUpdate(candidate, userId); var updatedCandidate = await candidateService.Update(candidate, value.VacanciesIds) .ConfigureAwait(false); unitOfWork.Save(); var candidateElasticModel = Mapper.Map <Candidate, CandidateElasticModel>(updatedCandidate); await candidateElasticService.UpdateCandidateElastic(candidateElasticModel); var notification = await notificationService.CreateNotification(updatedCandidate.HRM, NotificationTypes.Update, events); if (NotificationsHub.IsConnected(updatedCandidate.HRM)) { await NotificationsHub.PushNotification(notification); } unitOfWork.Save(); return(request.CreateResponse(HttpStatusCode.OK)); } catch (Exception ex) { logger.Error(ex, JsonConvert.SerializeObject(value)); return(request.CreateResponse(HttpStatusCode.InternalServerError)); } }
public async Task <HttpResponseMessage> UpdateTech(HttpRequestMessage request, [FromBody] InterviewUpdateDTO value) { try { var userId = ContextParser.GetUserId(request.GetRequestContext()); var techInterview = Mapper.Map <InterviewUpdateDTO, TechInterview>(value); techInterview.HRM = userId; var eventsForNotification = await eventService.RegisterTechInterviewUpdate(techInterview, userId); var updatedInterview = await interviewService.UpdateTechInterview(techInterview); unitOfWork.Save(); if (updatedInterview.Interviewer.HasValue) { var notification = await notificationService.CreateNotification(updatedInterview.Interviewer.Value, NotificationTypes.Update, eventsForNotification); if (NotificationsHub.IsConnected(updatedInterview.Interviewer.Value)) { await NotificationsHub.PushNotification(notification); } } unitOfWork.Save(); return(request.CreateResponse(HttpStatusCode.OK)); } catch (Exception ex) { logger.Error(ex, JsonConvert.SerializeObject(value)); return(request.CreateResponse(HttpStatusCode.InternalServerError)); } }
/// <summary> /// Helper method which steps through the children for a given constraint (aTemplateConstraint) and attaches any attributes to the /// given element (aElement)). /// </summary> /// <param name="aElement">Element to add the attributes to</param> /// <param name="aTemplateConstraint">Constraint to walk the children to find attributes</param> static private void AddBranchedAttributes(DocumentTemplateElement aElement, IConstraint aTemplateConstraint) { if (aTemplateConstraint.Children != null) { DocumentTemplateElement parsedElement = null; DocumentTemplateElementAttribute parsedAttribute = null; foreach (var child in aTemplateConstraint.Children) { var cp = new ContextParser(child.Context); cp.Parse(out parsedElement, out parsedAttribute); if (parsedElement != null) { parsedElement.IsBranch = child.IsBranch; parsedElement.IsBranchIdentifier = child.IsBranchIdentifier; } if (parsedAttribute != null) //we are only looking for attributes { parsedAttribute.SingleValue = child.Value; aElement.AddAttribute(parsedAttribute); } } } }
public async Task <HttpResponseMessage> Update(HttpRequestMessage request, [FromBody] VacancyInputDTO value) { try { var userId = ContextParser.GetUserId(request.GetRequestContext()); var vacancy = Mapper.Map <VacancyInputDTO, Vacancy>(value); var e = await eventService.RegisterVacancyUpdate(vacancy, userId); var updatedVacancy = await vacancyService.Update(vacancy, value.Candidates, userId) .ConfigureAwait(false); unitOfWork.Save(); var elasticVacancy = Mapper.Map <Vacancy, VacancyElasticModel>(updatedVacancy); await vacancyElasticService.UpdateVacancyElastic(elasticVacancy); var notification = await notificationService.CreateNotification(updatedVacancy.HRM, NotificationTypes.Update, e); if (NotificationsHub.IsConnected(updatedVacancy.HRM)) { await NotificationsHub.PushNotification(notification); } unitOfWork.Save(); return(request.CreateResponse(HttpStatusCode.OK)); } catch (Exception ex) { logger.Error(ex, JsonConvert.SerializeObject(value)); return(request.CreateResponse(HttpStatusCode.InternalServerError)); } }
public async Task <HttpResponseMessage> SetFeedbackGeneral(HttpRequestMessage request, [FromBody] GeneralInterviewFeedbackInDTO value) { try { var userId = ContextParser.GetUserId(request.GetRequestContext()); var generalInterview = Mapper.Map <GeneralInterviewFeedbackInDTO, GeneralInterview>(value); var updatedInterview = await interviewService.SetGeneralInterviewFeedback(generalInterview); var events = await eventService.RegisterGeneralInterviewFeedback(updatedInterview, userId); unitOfWork.Save(); await notificationService.MarkAsRead(userId, new List <int> { value.NotificationId }); var notification = await notificationService.CreateNotification(updatedInterview.HRM, NotificationTypes.Update, events); if (NotificationsHub.IsConnected(updatedInterview.HRM)) { await NotificationsHub.PushNotification(notification); } unitOfWork.Save(); return(request.CreateResponse(HttpStatusCode.OK)); } catch (Exception ex) { logger.Error(ex, JsonConvert.SerializeObject(value)); return(request.CreateResponse(HttpStatusCode.InternalServerError)); } }
public async Task <HttpResponseMessage> GetUnseenOfType(HttpRequestMessage request, int type, int skip, int amount) { try { var userId = ContextParser.GetUserId(request.GetRequestContext()); var notifications = await notificationService.GetUnseenOfType(userId, type, skip, amount); var result = Mapper.Map <ICollection <NotificationDTO> >(notifications); for (var i = 0; i < notifications.Count; i++) { result.ElementAt(i).Title = NotificationInfoStringBuilder.GetNotificationTitle(notifications.ElementAt(i)); } return(request.CreateResponse(HttpStatusCode.OK, result)); } catch (Exception ex) { logger.Error(ex, JsonConvert.SerializeObject(new { type, skip, amount })); return(request.CreateResponse(HttpStatusCode.InternalServerError)); } }
static public void ParseContextForElementAndAttribute(IConstraint aConstraint, out DocumentTemplateElement aElement, out DocumentTemplateElementAttribute aAttribute) { var cp = new ContextParser(aConstraint.Context); cp.Parse(out aElement, out aAttribute); }