/// <summary> /// Loads the context. /// </summary> /// <param name="context">The context.</param> public void LoadContext(IDictionary context) { _segment = (SegmentDto)context[_SegmentDtoString]; _expression = (ExpressionDto)context[_ExpressionDtoString]; RulesEditorCtrl.LoadContext(context); }
/// <summary> /// Loads the fresh. /// </summary> /// <returns></returns> private SegmentDto LoadFresh() { SegmentDto segment = null; if (SegmentId == 0) { // Create an empty segment segment = new SegmentDto(); SegmentDto.SegmentRow row = segment.Segment.NewSegmentRow(); row.ApplicationId = MarketingConfiguration.Instance.ApplicationId; row.Name = ""; row.DisplayName = ""; row.Description = ""; if (row.RowState == DataRowState.Detached) { segment.Segment.Rows.Add(row); } } else { segment = SegmentManager.GetSegmentDto(SegmentId); } // persist in session Session[_SegmentDtoEditSessionKey] = segment; return(segment); }
private async Task <Location> GetFlightLocation(FlightPlan flightPlan, DateTime dateTime) { var flightInitialLocation = await _context.InitialLocation.FindAsync(flightPlan.FlightId); DateTime time = flightInitialLocation.DateTime; DateTime prevTime = time; Location prevLocation = new Location { Longitude = flightInitialLocation.Longitude, Latitude = flightInitialLocation.Latitude }; //Location location = new Location(); TimeSpan flightTime = dateTime - flightInitialLocation.DateTime; var segments = _context.Segments.Where(s => s.FlightId == flightPlan.FlightId); SegmentDto prevSegment = null; foreach (Segment segment in segments) { flightTime = flightTime - TimeSpan.FromSeconds(segment.TimeSpanSeconds); if (flightTime.TotalSeconds < 0 || flightTime.TotalSeconds == 0) { return(CalculateLocation(flightInitialLocation, flightTime, prevSegment, segment)); } prevSegment = new SegmentDto { Latitude = segment.Latitude, Longitude = segment.Longitude, TimeSpanSeconds = segment.TimeSpanSeconds }; } return(null); }
private async Task <List <Model> > MapNStepModels(SegmentDto segment) { Model parentModel = new Model() { BaseModelId = 1, Name = segment.Models.FirstOrDefault().Name, CreatedAt = DateTime.Now, CreatedBy = "admin", UpdatedBy = "admin", UpdatedOn = DateTime.Now, ModelType = segment.ModelType, ModelConfig = JsonConvert.SerializeObject(new List <ModelParamDto>()), }; List <Model> models = segment.Models.FirstOrDefault().Models.Select(m => new Model() { BaseModelId = m.BaseModel.Id, Name = m.Name, CreatedAt = DateTime.Now, CreatedBy = "admin", UpdatedBy = "admin", UpdatedOn = DateTime.Now, ModelType = segment.ModelType, ModelConfig = JsonConvert.SerializeObject(m.Parameters), ParentModel = parentModel }).ToList(); List <Model> response = new List <Model>(); response.Add(parentModel); response.AddRange(models); return(response); }
/// <summary> /// Gets the Segment dto, checks permissions and caches results. /// </summary> /// <param name="segmentId">The segment id.</param> /// <returns></returns> public static SegmentDto GetSegmentDto(int segmentId) { // Assign new cache key, specific for site guid and response groups requested //string cacheKey = MarketingCache.CreateCacheKey("Segment", SegmentId.ToString()); SegmentDto dto = null; // check cache first //object cachedObject = MarketingCache.Get(cacheKey); //if (cachedObject != null) // dto = (SegmentDto)cachedObject; // Load the object if (dto == null) { SegmentAdmin Segment = new SegmentAdmin(); Segment.Load(segmentId); dto = Segment.CurrentDto; // Insert to the cache collection //MarketingCache.Insert(cacheKey, dto, MarketingConfiguration.CacheConfig.SegmentCollectionTimeout); } dto.AcceptChanges(); return(dto); }
/// <summary> /// Saves the segment. /// </summary> /// <param name="dto">The dto.</param> public static void SaveSegment(SegmentDto dto) { if (dto == null) { throw new ArgumentNullException("dto", String.Format("SegmentDto can not be null")); } //TODO: check concurrency when updating the records //TODO: need to check security roles here, // The procedure will be following: // 1. Retrieve the record from the database for each category that is about to be updated // 2. Check Write permissions (if failed generate the error and exit) // 3. Otherwise proceed to update // Continue with security checks and other operations /* * foreach (SegmentDto.SegmentRow row in dto.Segment.Rows) * { * // Check Security * IDataReader reader = DataHelper.CreateDataReader(dto.SegmentSecurity, String.Format("SegmentId = -1 or SegmentId = {0}", row.SegmentId)); * PermissionRecordSet recordSet = new PermissionRecordSet(PermissionHelper.ConvertReaderToRecords(reader)); * if (!PermissionManager.CheckPermission(SegmentScope.Segment, Permission.Read, recordSet)) * { * row.Delete(); * continue; * } * } * */ SegmentAdmin admin = new SegmentAdmin(dto); admin.Save(); }
internal IPolylineSegment CreatePolylineSegmentFromDto(SegmentDto segment, Constants.CircleOrigin origin) { IPolylineSegment polylineSegment; var dto = segment as ArcSegmentDto; if ( dto != null ) { polylineSegment = CreateTurnCircleArcSegment(dto, origin); } else { var segmentDto = segment as LineSegmentDto; if ( segmentDto != null ) { polylineSegment = CreateLineFromLineDto(segmentDto); } else { throw new ArgumentException( "Unknown polyline segment {0}!".Inject(segment.GetType().FullName)); } } return polylineSegment; }
/// <summary> /// Processes the delete command. /// </summary> /// <param name="items">The items.</param> void ProcessDeleteCommand(string[] items) { for (int i = 0; i < items.Length; i++) { string[] keys = EcfListView.GetPrimaryKeyIdStringItems(items[i]); if (keys != null) { string id = keys[0]; List <int> expressionList = new List <int>(); SegmentDto dto = SegmentManager.GetSegmentDto(Int32.Parse(id)); if (dto.Segment.Count > 0) { SegmentDto.SegmentRow segmentRow = dto.Segment[0]; foreach (SegmentDto.SegmentConditionRow condition in segmentRow.GetSegmentConditionRows()) { expressionList.Add(condition.ExpressionId); } dto.Segment[0].Delete(); SegmentManager.SaveSegment(dto); } // Delete corresponding expressions foreach (int expressionId in expressionList) { ExpressionDto expressionDto = ExpressionManager.GetExpressionDto(expressionId); if (expressionDto != null && expressionDto.Expression.Count > 0) { expressionDto.Expression[0].Delete(); ExpressionManager.SaveExpression(expressionDto); } } } } }
/// <summary> /// Handles the Load event of the Page control. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param> protected void Page_Load(object sender, EventArgs e) { _ExpressionDto = (ExpressionDto)HttpContext.Current.Session[_ExpressionDtoEditSessionKey]; _SegmentDto = HttpContext.Current.Session[_SegmentDtoEditSessionKey] as SegmentDto; if (_ExpressionDto == null || _SegmentDto == null) // close the window { CommandParameters cp = new CommandParameters(_RuleEditCommandString); CommandHandler.RegisterCloseOpenedFrameScript(this.Page, cp.ToString()); ExprFilter.Visible = false; } if (!this.IsPostBack) { if (_ExpressionDto != null) { //Request for create expresion if (IsCreateExpression) { //Add new ExpressionCollection to session ExpressionFilters.Add(new FilterExpressionNodeCollection()); //Change iterator position to new collections ExpressionIndex = ExpressionFilters.Count - 1; } else { BindForm(); } BindExpressionEditor(ExpressionFilter); } } }
/// <summary> /// Initializes a new instance of the <see cref="MarketingHelper"/> class. /// </summary> /// <param name="campaigns">The campaigns.</param> /// <param name="expressions">The expressions.</param> /// <param name="policies">The policies.</param> /// <param name="promotions">The promotions.</param> /// <param name="segments">The segments.</param> public MarketingHelper(CampaignDto campaigns, ExpressionDto expressions, PolicyDto policies, PromotionDto promotions, SegmentDto segments) { _Campaigns = campaigns; _Expressions = expressions; _Policies = policies; _Promotions = promotions; _Segments = segments; }
/// <summary> /// Loads the data and data bind. /// </summary> /// <param name="sortExpression">The sort expression.</param> private void LoadDataAndDataBind(string sortExpression) { SegmentDto dto = SegmentManager.GetSegmentDto(); if (dto.Segment != null) { DataView view = dto.Segment.DefaultView; view.Sort = sortExpression; MyListView.DataSource = view; } MyListView.CurrentListView.PrimaryKeyId = EcfListView.MakePrimaryKeyIdString("SegmentId"); MyListView.DataBind(); }
/// <summary> /// Finds the design expression id. /// </summary> /// <param name="segmentDto">The segment dto.</param> /// <returns></returns> private int FindDesignExpressionId(SegmentDto segmentDto) { if (segmentDto.SegmentCondition.Count > 0) { DataView view = segmentDto.SegmentCondition.DefaultView; //view.RowFilter = String.Format("name like '{0}*'", _RulesPrefix); if (view.Count > 0) { return(Int32.Parse(view[0]["ExpressionId"].ToString())); } } return(0); }
public ActionResult <int> Add(SegmentDto model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } int userId = this.GetCurrentUserId(); int segmentId = SaveSegment(userId, model); SegmentAnalyser.AnalyseSegment(context, userId, segmentId); return(segmentId); }
private void FromSegmentsToSegmentsDto(List <Segment> segments, List <SegmentDto> segmentsDto) { List <SegmentDto> newSegments = new List <SegmentDto>(); foreach (Segment s in segments) { var segment = new SegmentDto { Longitude = s.Longitude, Latitude = s.Latitude, TimeSpanSeconds = s.TimeSpanSeconds }; segmentsDto.Add(segment); } }
private async Task <List <Model> > MapOneStepModel(SegmentDto segment) { return(segment.Models.Select(m => new Model() { BaseModelId = m.BaseModel.Id, Name = m.Name, CreatedAt = DateTime.Now, CreatedBy = "admin", UpdatedBy = "admin", UpdatedOn = DateTime.Now, ModelType = segment.ModelType, ModelConfig = JsonConvert.SerializeObject(m.Parameters), ParentId = 0, }).ToList()); }
public CreateSegmentScreenViewModel(MainContext context, RideDto ride) : base(context) { segment = new SegmentDto(); Ride = ride; count = 1; displayText = "Tap on the map to set a start point"; MapViewModel = new MapControlViewModel( context, Ride?.DisplayName ?? "Map", ride != null ? PolyUtils.GetMapLocations(Ride.Locations, Ride.Jumps) : new List <MapLocation>(), isReadOnly: false, showRideFeatures: false, goToMapPageOnClick: false, mapType: MapType.Satellite, canChangeMapType: true); MapViewModel.MapTapped += MapViewModel_MapTapped; }
public async Task <ServiceResponseDto> AddSegment(SegmentDto segment) { try { Segment newSegment = new Segment(); newSegment.Name = segment.Name; newSegment.Description = segment.Description; newSegment.ModelType = segment.ModelType; newSegment.IsActive = true; newSegment.CreatedAt = DateTime.Now; newSegment.CreatedBy = "admin"; newSegment.UpdatedBy = "admin"; newSegment.UpdatedOn = DateTime.Now; switch (segment.ModelType) { case ModelTypes.OneStep: newSegment.Models = await MapOneStepModel(segment); break; case ModelTypes.NStep: newSegment.Models = await MapNStepModels(segment); break; } long segmentId = await _repository.AddSegment(newSegment); return(new ServiceResponseDto() { Id = segmentId, Error = string.Empty, Message = "Segment Added", StatusCode = (int)HttpStatusCode.OK, Success = true }); } catch (Exception e) { return(new ServiceResponseDto() { Message = "Error adding segment", StatusCode = (int)HttpStatusCode.OK, Success = false }); } }
private int SaveSegment(int userId, SegmentDto model) { Segment segment = new Segment { Name = model.Name, UserId = userId, }; segment.SegmentLocation = model.Locations .Select(i => new SegmentLocation { Latitude = i.Latitude, Longitude = i.Longitude, Order = i.Order, }) .ToList(); context.Segment.Add(segment); context.SaveChanges(); return(segment.SegmentId); }
/// <summary> /// Saves the changes. /// </summary> /// <param name="context">The context.</param> public void SaveChanges(IDictionary context) { int expressionId = 0; SegmentDto dto = (SegmentDto)context[_SegmentDtoString]; SegmentDto.SegmentRow row = null; if (dto.Segment.Count > 0) { row = dto.Segment[0]; expressionId = FindDesignExpressionId(dto); } else { row = dto.Segment.NewSegmentRow(); row.ApplicationId = MarketingConfiguration.Instance.ApplicationId; } row.Name = SegmentName.Text; row.DisplayName = DisplayName.Text; row.Description = Description.Text; //Tell RulesEditorCtrl save changes RulesEditorCtrl.SaveChanges(); if (row.RowState == DataRowState.Detached) { dto.Segment.Rows.Add(row); } /* * // design-ui denotes that this expression was created using design ui * if(ExprFilter.Visible) * ExprFilter.Provider.SaveFilters(_RulesPrefix, String.Format("{0}:{1}", row.SegmentId, expressionId), ExprFilter.NodeCollection[0].ChildNodes); * */ }
/// <summary> /// Loads the context. /// </summary> private void LoadContext() { //if (SegmentId > 0) { SegmentDto segment = null; ExpressionDto expression = null; if (!this.IsPostBack && (!this.Request.QueryString.ToString().Contains("Callback=yes"))) // load fresh on initial load { segment = LoadFresh(); expression = LoadFreshExpression(); } else // load from session { segment = (SegmentDto)Session[_SegmentDtoEditSessionKey]; expression = (ExpressionDto)Session[_ExpressionDtoEditSessionKey]; if (segment == null) { segment = LoadFresh(); } if (expression == null) { expression = LoadFreshExpression(); } } // Put a dictionary key that can be used by other tabs IDictionary dic = new ListDictionary(); dic.Add(_SegmentDtoString, segment); dic.Add(_ExpressionDtoString, expression); // Call tabs load context ViewControl.LoadContext(dic); } }
public async Task <ServiceResponseDto> AddSegment([FromBody] SegmentDto segment) { return(await _manager.AddSegment(segment)); }
/// <summary> /// Loads the context. /// </summary> /// <param name="context">The context.</param> public void LoadContext(System.Collections.IDictionary context) { _segment = (SegmentDto)context[_SegmentDtoString]; _expression = (ExpressionDto)context[_ExpressionDtoString]; }
public async Task <int> UploadSegment(SegmentDto segment) { return(await PostAsync <int>("segments/add", segment)); }
/// <summary> /// Initializes a new instance of the <see cref="SegmentAdmin"/> class. /// </summary> internal SegmentAdmin() { _DataSet = new SegmentDto(); }
/// <summary> /// Handles the SaveChanges event of the EditSaveControl control. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param> void EditSaveControl_SaveChanges(object sender, SaveControl.SaveEventArgs e) { // Validate form if (!this.Page.IsValid) { e.RunScript = false; return; } SegmentDto segment = (SegmentDto)Session[_SegmentDtoEditSessionKey]; ExpressionDto expression = (ExpressionDto)Session[_ExpressionDtoEditSessionKey]; if (segment == null && SegmentId > 0) { segment = SegmentManager.GetSegmentDto(SegmentId); } else if (segment == null && SegmentId == 0) { segment = new SegmentDto(); } if (expression == null && SegmentId > 0) { expression = ExpressionManager.GetExpressionBySegmentDto(SegmentId); } else if (expression == null && SegmentId == 0) { expression = new ExpressionDto(); } /* * // if we add a new segment, remove all other segments from Dto that is passed to control that saves changes * if (SegmentId == 0 && segment != null && segment.Segment.Count > 0) * { * SegmentDto.SegmentRow[] rows2del = (SegmentDto.SegmentRow[])segment.Segment.Select(String.Format("{0} <> {1}", _SegmentIdString, SegmentId)); * if (rows2del != null) * foreach (SegmentDto.SegmentRow row in rows2del) * segment.Segment.RemoveSegmentRow(row); * }*/ IDictionary context = new ListDictionary(); context.Add(_SegmentDtoString, segment); context.Add(_ExpressionDtoString, expression); ViewControl.SaveChanges(context); // save expressionDto if (expression.HasChanges()) { ExpressionManager.SaveExpression(expression); } // update segment conditions foreach (ExpressionDto.ExpressionRow tmpRow in expression.Expression.Rows) { // skip deleted rows if (tmpRow.RowState == DataRowState.Deleted) { continue; } // add SegmentConditionRow SegmentDto.SegmentConditionRow[] segmentConditionRows = (SegmentDto.SegmentConditionRow[])segment.SegmentCondition.Select(String.Format("ExpressionId={0}", tmpRow.ExpressionId)); if (segmentConditionRows == null || segmentConditionRows.Length == 0) { // add new expression SegmentDto.SegmentConditionRow newSCRow = segment.SegmentCondition.NewSegmentConditionRow(); newSCRow.ExpressionId = tmpRow.ExpressionId; newSCRow.SegmentId = segment.Segment[0].SegmentId; if (newSCRow.RowState == DataRowState.Detached) { segment.SegmentCondition.Rows.Add(newSCRow); } } } // save segmentDto if (segment.HasChanges()) { SegmentManager.SaveSegment(segment); } // we don't need to store Dto in session any more Session.Remove(_SegmentDtoEditSessionKey); Session.Remove(_ExpressionDtoEditSessionKey); }
/// <summary> /// Returns customer segments for specified customer or organization. /// </summary> /// <param name="context">The context. Should include ContextConstants.CustomerProfile of type ProfileBase</param> /// <param name="customerPrincipalId">The customer principal id.</param> /// <param name="organizationPrincipalId">The organization principal id.</param> /// <returns>int list of customer segment ids</returns> public List <int> GetCustomerSegments(Dictionary <string, object> context, Guid customerPrincipalId, Guid organizationPrincipalId) { List <int> segments = new List <int>(); MarketingHelper helper = GetMarketingHelper(true); SegmentDto segmentsDto = helper.Segments; PromotionContext promotionContext = new PromotionContext(context, null, null); // Cycle through customer segments foreach (SegmentDto.SegmentRow segmentRow in segmentsDto.Segment) { bool includeSegment = false; bool excludeSegment = false; // Check if profile is directly specified in the members tables foreach (SegmentDto.SegmentMemberRow memberRow in segmentRow.GetSegmentMemberRows()) { if (memberRow.PrincipalId == customerPrincipalId || memberRow.PrincipalId == organizationPrincipalId) { if (memberRow.Exclude) { excludeSegment = true; break; } else { includeSegment = true; break; } } } // if explicitely excluded, skip the segment if (excludeSegment) { continue; } // Validate expressions, if any of the expression is met, user is part of the group foreach (SegmentDto.SegmentConditionRow condition in segmentRow.GetSegmentConditionRows()) { ExpressionDto.ExpressionRow expressionRow = helper.Expressions.Expression.FindByExpressionId(condition.ExpressionId); if (expressionRow != null && !String.IsNullOrEmpty(expressionRow.ExpressionXml)) { ValidationResult result = ValidateExpression(expressionRow.ApplicationId.ToString() + "-" + expressionRow.Category + "-" + expressionRow.ExpressionId.ToString(), expressionRow.ExpressionXml, promotionContext); if (!result.IsValid) { includeSegment = false; continue; } else { includeSegment = true; break; } } } if (!includeSegment) { continue; } segments.Add(segmentRow.SegmentId); } return(segments); }
private static Location CalculateLocation(InitialLocation flightInitialLocation, TimeSpan flightTime, SegmentDto prevSegment, Segment segment) { Location location = new Location(); if (flightTime.TotalSeconds == 0) { return(new Location { Latitude = segment.Latitude, Longitude = segment.Longitude }); } double ratio = ((segment.TimeSpanSeconds + flightTime.TotalSeconds) / (double)segment.TimeSpanSeconds); if (prevSegment == null) { location.Latitude = flightInitialLocation.Latitude + ratio * (segment.Latitude - flightInitialLocation.Latitude); location.Longitude = flightInitialLocation.Longitude + ratio * (segment.Longitude - flightInitialLocation.Longitude); return(location); } location.Latitude = prevSegment.Latitude + (ratio * (segment.Latitude - prevSegment.Latitude)); location.Longitude = prevSegment.Longitude + (ratio * (segment.Longitude - prevSegment.Longitude)); return(location); }
/// <summary> /// Initializes a new instance of the <see cref="SegmentAdmin"/> class. /// </summary> /// <param name="dto">The dto.</param> internal SegmentAdmin(SegmentDto dto) { _DataSet = dto; }