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