private void Start()
{
//Add the map incase its missing
mapConfig = GameObject.FindGameObjectWithTag("Map").GetComponent <MapConfig>();
xPosMax = mapConfig.tileMap.mapSizeX * mapConfig.tileMap.offset;
zPosMax = mapConfig.tileMap.mapSizeY * mapConfig.tileMap.offset;
}
public void OnSnapPointRequested(SnapPointRequestedEventArgs e)
{
// If there are no restrictions active, don't interfere
if (!activeRestrictions.Any())
{
return;
}
double tolerance = MapConfig.GetProjectedMouseTolerance(_context.Map);
var snapPointChecker = new SnapPointCandidateChecker(new Coordinate(e.PointX, e.PointY), tolerance);
// First try to snap to an intersection of two restrictions (if possible)
bool success = snapPointChecker.ContainsBetterCandidate(c => GetIntersectionBetweenRestrictions(c, tolerance));
// Then try to snap to an intersection of a restriction with layer geometries
if (!success)
{
success = snapPointChecker.ContainsBetterCandidate(c => GetIntersectionsWithLayerFeatures(c, tolerance));
}
// Try a regular snap to the restrictions
if (!success)
{
success = snapPointChecker.ContainsBetterCandidateWithoutTolerance(GetSnapPoints);
}
e.SnappedX = snapPointChecker.BestSnapPoint.X;
e.SnappedY = snapPointChecker.BestSnapPoint.Y;
e.IsFinal = true;
e.IsFound = true;
}
/// <summary>
/// Update map settings
/// </summary>
/// <param name="mapSettings"></param>
internal void UpdateMapSettings(MapSetting mapSettings, string mapFile)
{
MapConfig config = readMapConfigFromFile(mapFile);
config.map = mapSettings;
this.saveMapConfigToFile(config, mapFile);
}
private void reloadAllData()
{
mapData = MapConfig.loadMap(curActiveMapNo);
setPal();
int videoPageId = curActiveVideo;
videos = new ImageList[4];
var chunk = ConfigScript.getVideoChunk(videoPageId);
for (int i = 0; i < 4; i++)
{
videos[i] = new ImageList();
videos[i].ImageSize = new Size(16, 16);
var images = new Image[256];
for (int t = 0; t < 256; t++)
{
images[t] = UtilsGDI.ResizeBitmap(ConfigScript.videoNes.makeImage(t, chunk, curPal, i), 16, 16);
}
videos[i].Images.AddRange(images);
}
prepareBlocksPanel();
mapScreen.Size = new Size(mapData.width * 16, mapData.height * 16);
mapScreen.Invalidate();
}
public void Export()
{
FTWorldMap worldMap = this;
MapConfig data = new MapConfig();
data.MapID = worldMap.MapID;
data.MapName = worldMap.MapName;
data.MapType = worldMap.MapType;
data.AllowPK = worldMap.AllowPK;
data.AllowRide = worldMap.AllowRide;
data.AllowTrade = worldMap.AllowTrade;
ExportDCFGByElement <FTBorn, MapBorn>(data.MapBorns, worldMap);
ExportDCFGByElement <FTArea, MapArea>(data.MapAreas, worldMap);
ExportDCFGByElement <FTAreaMine, MapAreaMine>(data.MapAreaMines, worldMap);
ExportDCFGByElement <FTAreaMonster, MapAreaMonster>(data.MapAreaMonsters, worldMap);
ExportDCFGByElement <FTBarrier, MapBarrier>(data.MapBarriers, worldMap);
ExportDCFGByElement <FTMutiPoint, MapMutiPoint>(data.MapMutiPoints, worldMap);
ExportDCFGByElement <FTNpc, MapNpc>(data.MapNpcs, worldMap);
ExportDCFGByElement <FTPath, MapPath>(data.MapPaths, worldMap);
ExportDCFGByElement <FTPortal, MapPortal>(data.MapPortals, worldMap);
ExportDCFGByElement <FTStep, MapStep>(data.MapSteps, worldMap);
ExportDCFGByElement <FTTimer, MapTimer>(data.MapTimers, worldMap);
ExportDCFGByElement <FTEvent, MapEvent>(data.MapEvents, worldMap);
string fileName = string.Format("{0}/Resources/Text/Map/{1}.xml", Application.dataPath, data.MapID);
data.Save(fileName);
}
public void Import()
{
FTWorldMap worldMap = this;
string fileName = string.Format("Text/Map/{0}", worldMap.MapID);
MapConfig data = new MapConfig();
data.Load(fileName);
worldMap.MapID = data.MapID;
worldMap.MapName = data.MapName;
worldMap.MapType = data.MapType;
worldMap.AllowPK = data.AllowPK;
worldMap.AllowRide = data.AllowRide;
worldMap.AllowTrade = data.AllowTrade;
ImportEvents(data.MapEvents, worldMap);
ImportDCFGByElement <FTBorn, MapBorn>(data.MapBorns, worldMap);
ImportDCFGByElement <FTArea, MapArea>(data.MapAreas, worldMap);
ImportDCFGByElement <FTAreaMine, MapAreaMine>(data.MapAreaMines, worldMap);
ImportDCFGByElement <FTAreaMonster, MapAreaMonster>(data.MapAreaMonsters, worldMap);
ImportDCFGByElement <FTBarrier, MapBarrier>(data.MapBarriers, worldMap);
ImportDCFGByElement <FTMutiPoint, MapMutiPoint>(data.MapMutiPoints, worldMap);
ImportDCFGByElement <FTNpc, MapNpc>(data.MapNpcs, worldMap);
ImportDCFGByElement <FTPath, MapPath>(data.MapPaths, worldMap);
ImportDCFGByElement <FTPortal, MapPortal>(data.MapPortals, worldMap);
ImportDCFGByElement <FTStep, MapStep>(data.MapSteps, worldMap);
ImportDCFGByElement <FTTimer, MapTimer>(data.MapTimers, worldMap);
MapData = data;
}
void Awake()
{
map = GameObject.Find("Map");
terrains = GameObject.Find("Terrains");
meshRenderer = map.GetComponent <MeshRenderer>();
list = new List <MapConfig>();
TextAsset obj = (TextAsset)AssetDatabase.LoadAssetAtPath("Assets/Game/Config/stage_map.csv", typeof(TextAsset));
string text = obj.text;
StringReader stringReader = new StringReader(text);
stringReader.ReadLine();
stringReader.ReadLine();
while (true)
{
string line = stringReader.ReadLine();
if (line == null)
{
break;
}
string[] csv = line.Split(';');
if (csv.Length != 0 && !string.IsNullOrEmpty(csv[0]))
{
MapConfig mapConfig = new MapConfig();
mapConfig.ParseCsv(csv, false);
list.Add(mapConfig);
}
}
index = 0;
StartCoroutine(Doing());
}
void OpenMap(MapConfig mapConfig)
{
Clear();
if (mapConfig.id < 100)
{
meshRenderer.sharedMaterial.mainTexture = Resources.Load <Texture2D>(mapConfig.terrain);
map.SetActive(true);
terrains.SetActive(false);
}
else
{
GameObject prefab = Resources.Load <GameObject>(mapConfig.terrain);
GameObject go = GameObject.Instantiate(prefab);
go.transform.SetParent(terrains.transform);
go.transform.position = Vector3.zero;
map.SetActive(false);
terrains.SetActive(true);
// Transform map = go.transform.Find("Map");
// if(map != null)
// {
// MeshRenderer mapRenderer = map.GetComponent<MeshRenderer>();
// if(mapRenderer != null)
// {
// mapRenderer.sharedMaterial.shader = Shader.Find("ihaiu/Terrain_3Texture_1Shade");
// }
// }
}
PathUtil.CheckPath(root, false);
string filename = root + mapConfig.id + ".png";
ScreenshotTool.Shot(Camera.main, 150, 100, false, filename);
}
public ProductViewModel ToViewModel(Product Product)
{
var config = new MapConfig().ToViewModel();
var mapper = config.CreateMapper();
return(mapper.Map <ProductViewModel>(Product));
}
public IEnumerable <ProductViewModel> ToListViewModel(IEnumerable <Product> Products)
{
var config = new MapConfig().ToViewModel();
var mapper = config.CreateMapper();
return(mapper.Map <IEnumerable <Product>, IEnumerable <ProductViewModel> >(Products));
}
public QualityResultViewModel ToViewModel(QualityResult QualityResult)
{
var config = new MapConfig().ToViewModel();
var mapper = config.CreateMapper();
return(mapper.Map <QualityResultViewModel>(QualityResult));
}
public IEnumerable <QualityResultViewModel> ToListViewModel(IEnumerable <QualityResult> QualityResults)
{
var config = new MapConfig().ToViewModel();
var mapper = config.CreateMapper();
return(mapper.Map <IEnumerable <QualityResult>, IEnumerable <QualityResultViewModel> >(QualityResults));
}
private void DisplayBackGround()
{
var sceneId = LoadingPresenter.Instance.sceneId.Fetch();
var config = MapConfig.Get(sceneId);
m_BackGround.SetSprite(config.backGround);
}
public static void Init(string fileName)
{
MapConfig <SongDataConfig> ser = new MapConfig <SongDataConfig>();
ser.FileName = fileName;
Config = ser.ReadEntity();
}
public IObservable <Unit> Load(Transform mapTransform, MapConfig mapConfig)
{
return(_tilesPositionService
.GetMostRecent(mapTransform.position.y)
.Zip(_boardItemsRepository.GetMostRecent(), (positions, items) => (positions, items))
.Select(
tuple =>
{
var(positions, items) = tuple;
foreach (var item in items)
{
var(component, gameObject) = _holderFactory.Create(mapTransform, false);
var flattenedIndex = _coordinateService.GetFlattenArrayIndexFromAxialCoordinate(
item.Coordinate.X,
item.Coordinate.Z,
mapConfig
);
gameObject.transform.position = positions[flattenedIndex];
gameObject.transform.parent = mapTransform;
component.Initialize(item);
}
_finishedLoadingEventStream.OnNext(Unit.Default);
return Unit.Default;
}
));
}
public IEnumerable <LaboratoryViewModel> ToListViewModel(IEnumerable <Laboratory> Laboratorys)
{
var config = new MapConfig().ToViewModel();
var mapper = config.CreateMapper();
return(mapper.Map <IEnumerable <Laboratory>, IEnumerable <LaboratoryViewModel> >(Laboratorys));
}
public LaboratoryViewModel ToViewModel(Laboratory Laboratory)
{
var config = new MapConfig().ToViewModel();
var mapper = config.CreateMapper();
return(mapper.Map <LaboratoryViewModel>(Laboratory));
}
public void Load_xml_config_with_entity_non_existing_map_should_throw()
{
string testMapfile = Path.Combine(SessionHelper.BaseDirectory, "TestFiles", "MapConfigTests", "Test002.data.xml");
MapConfig config = new MapConfig();
Assert.Throws <MappingException>(() => config.Load(testMapfile));
}
public void SnapSlope(ICoordinate anchor, double slope, ICoordinate offsetAnchor = null, bool needsUserInput = true, int handle = 0)
{
var restriction = new LinearRestriction(anchor, slope, handle);
double offset = 0;
if (offsetAnchor != null)
{
double tolerance = MapConfig.GetProjectedMouseTolerance(_context.Map);
offset = restriction.GetOffsetDistance(offsetAnchor, tolerance);
restriction.OffsetByDistance(offset);
}
AddRestriction(restriction);
if (!needsUserInput)
{
return;
}
void inputAction(double value)
{
restriction.OffsetByDistance(value);
restriction.RefreshGuideline(_context.Map as IMap);
}
// Show input box to end-user to enter the bearing
// live updating the map with the snap line
RequestUserInput(
inputAction,
"Offset:",
offset,
anchor
);
}
public void Load_statement_not_depending_on_entity_with_no_name_should_throw()
{
string testMapfile = Path.Combine(SessionHelper.BaseDirectory, "TestFiles", "MapConfigTests", "Test_statement_invalid_missing_name.xml");
MapConfig config = new MapConfig();
Assert.Throws <MappingSerializationException>(() => config.Load(testMapfile));
}
/// <summary>
/// Generates the code for each entity map.
/// </summary>
/// <param name="templateFile">The templateFile.</param>
/// <param name="workingFolder">The working folder.</param>
/// <param name="mapfile">The mapfile.</param>
/// <param name="fileNameFunction">The file name function.</param>
/// <param name="excludedTables">The excluded tables.</param>
/// <param name="properties"></param>
public void GenerateCodeForEachEntityMap(string templateFile, string workingFolder, string mapfile,
Func <string, int?, string> fileNameFunction = null, IDictionary <string, string> properties = null, params string[] excludedTables)
{
var project = MapConfig.Create(mapfile, true);
GenerateCodeForEachEntityMap(templateFile, workingFolder, project, fileNameFunction, properties, excludedTables);
}
public void Load_generic_statement_without_operation_type_should_throw()
{
string testMapfile = Path.Combine(SessionHelper.BaseDirectory, "TestFiles", "MapConfigTests", "Test_statement_invalid_statement_operationType.xml");
MapConfig config = new MapConfig();
Assert.Throws <MappingSerializationException>(() => config.Load(testMapfile));
}
public UserViewModel ToViewModel(User User)
{
var config = new MapConfig().ToViewModel();
var mapper = config.CreateMapper();
return(mapper.Map <UserViewModel>(User));
}
public IEnumerable <UserViewModel> ToListViewModel(IEnumerable <User> Users)
{
var config = new MapConfig().ToViewModel();
var mapper = config.CreateMapper();
return(mapper.Map <IEnumerable <User>, IEnumerable <UserViewModel> >(Users));
}
private void reloadAllData()
{
mapDatas = MapConfig.loadMap(curActiveMapNo);
setPal();
int videoPageId = curActiveVideo;
videos = new Image[4][];
var chunk = ConfigScript.getVideoChunk(videoPageId);
for (int i = 0; i < 4; i++)
{
var images = new Image[256];
for (int t = 0; t < 256; t++)
{
images[t] = UtilsGDI.ResizeBitmap(ConfigScript.videoNes.makeImage(t, chunk, curPal, i), 16, 16);
}
videos[i] = images;
}
blocksScreen.Invalidate();
mapScreen.Size = new Size(mapDatas[0].width * 16, mapDatas[0].height * 16);
mapScreen.Invalidate();
mapScreen2.Visible = showSecondNametable;
mapScreen2.Size = mapScreen.Size;
mapScreen2.Location = new Point(mapScreen.Location.X + mapScreen.Width, mapScreen2.Location.Y);
mapScreen2.Invalidate();
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
RouteConfig.RegisterRoutes(RouteTable.Routes);
MapConfig.RegisterMap();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
}
private MapUtil()
{
mapConfig = MapConfig.getInstance();
ballConfig = BallConfig.getInstance();
row = Convert.ToInt32(mapConfig.MapWidth() / mapConfig.TileWidth());
col = Convert.ToInt32(mapConfig.MapHeight() / mapConfig.TileHeight());
}
public Config(string configSuffix = "")
{
configSuffix = configSuffix.Trim().Replace(" ", "");
if (configSuffix != "")
{
_configFile = "config_" + configSuffix + ".config";
}
var appData = (string)ConfigItems.Debug_Logpath.Default;
if (!Directory.Exists(appData))
{
Directory.CreateDirectory(appData);
}
string config = Path.Combine(appData, _configFile);
_c = new MapConfig(config);
Fields.Elpis_HotKeys = new Dictionary <int, HotkeyConfig>();
//If not config file, init with defaults then save
if (!File.Exists(config))
{
LoadConfig();
SaveConfig();
}
}
/// <summary>
/// Save config as JSON-file
/// </summary>
/// <param name="mapConfig"></param>
private void saveMapConfigToFile(MapConfig mapConfig)
{
string file = String.Format("{0}App_Data\\{1}", HostingEnvironment.ApplicationPhysicalPath, this.mapFile);
string jsonOutput = JsonConvert.SerializeObject(mapConfig, Formatting.Indented);
System.IO.File.WriteAllText(file, jsonOutput);
}
private Map Generate()
{
MapConfig config = new MapConfig();
config.type = MapType.A;
config.size = new int[2] {
(int)size.x, (int)size.y
};
config.seed = seed;
config.frequency = frequency;
config.amplitude = amplitude;
config.persistance = persistance;
config.octaves = octaves;
config.bushLevel = bushLevel;
config.targetPointWidth = (int)targetPointSize.x;
config.targetPointHeight = (int)targetPointSize.y;
config.numBirthPoints = numBirthPoints;
config.birthPointWidth = (int)birthPointSize.x;
config.birthPointHeight = (int)birthPointSize.y;
config.pathBreadth = pathBreadth;
config.pathCurvity = pathCurvity;
map = new Map(config);
return(map);
}
public void TestInitialize()
{
var config = ConfigurationFactory.Configuration;
MapConfig = config.MapConfig;
generator = new MapGenerator(config);
}
private static void ConfigureFileMaps(IImageConverter imageConverter)
{
// Map a file to a base64 string if available.
var fileConfig = new MapConfig<object, object>();
fileConfig.AfterMapAction = (content, model) =>
{
var fileProperties = model.GetType().GetProperties().Where(pr => pr.GetCustomAttributes(typeof(ImageAttribute), true).Any());
foreach (var fileProperty in fileProperties)
{
var file = model.GetPropertyValue(fileProperty.Name) as FileDisplayModel;
var attribute = fileProperty.GetAttribute<ImageAttribute>();
var sizeX = string.IsNullOrWhiteSpace(attribute.WidthProperty) ? attribute.Width : (int)model.GetPropertyValue(attribute.WidthProperty);
var sizeY = string.IsNullOrWhiteSpace(attribute.HeightProperty) ? attribute.Height : (int)model.GetPropertyValue(attribute.HeightProperty);
string path = null;
if (file != null && file.Folder != null)
{
var imagePath = string.Format("{0}.{1}", System.IO.Path.Combine(file.Folder, file.Path, file.FileName), file.Extension);
path = imageConverter.ImageAsPath(imagePath, sizeX, sizeY, attribute.KeepAspectRatio);
}
if (model.HasProperty(fileProperty.Name + "Path"))
{
model.SetPropertyValue(fileProperty.Name + "Path", path);
}
}
};
DataMapper.RegisterMapConfig(fileConfig);
}
private void Init()
{
if (!_initialized)
{
var config = new MapConfig<IntEntity, IntEntityViewModel>();
config.MembersToMap.Add(d => d.EntityName, s => s.Name);
config.MembersToMap.Add(d => d.Order, s => s.Number);
config.MembersToMap.Add(d => d.Required, s => s.IsRequired);
config.MembersToMap.Add(d => d.Date, s => s.StartDate);
DataMapper.RegisterMapConfig(config);
var returnConfig = new MapConfig<IntEntityViewModel, IntEntity>();
returnConfig.MembersToMap.Add(d => d.Name, s => s.EntityName);
returnConfig.MembersToMap.Add(d => d.Number, s => s.Order);
returnConfig.MembersToMap.Add(d => d.IsRequired, s => s.Required);
returnConfig.MembersToMap.Add(d => d.StartDate, s => s.Date);
DataMapper.RegisterMapConfig(returnConfig);
var testConfig = new MapConfig<TestEntity, TestEntityViewModel>();
testConfig.MembersToIgnore.Add(d => d.Description);
DataMapper.RegisterMapConfig(testConfig);
}
}
internal static void ConfigureEntityMaps()
{
if (_isInitialized)
{
return;
}
DataMapper.CreateMap<PlatformEntity, SelectRelationDto<Guid>>().ForMember(s => s.EntityId, c => c.MapFrom(p => p.Id));
var idConfig = new MapConfig<IContent, EntityListModel>();
idConfig.MembersToMap.Add(d => d.Id, s => s.EntityId);
DataMapper.RegisterMapConfig(idConfig);
var listUrlConfig = new MapConfig<IContent, EntityListModel>();
listUrlConfig.MembersToMap.Add(d => d.Url, s => s.Entity.Url);
DataMapper.RegisterMapConfig(listUrlConfig);
var detailUrlConfig = new MapConfig<IContent, EntityViewModel>();
detailUrlConfig.MembersToMap.Add(d => d.Url, s => s.Entity.Url);
DataMapper.RegisterMapConfig(detailUrlConfig);
var entityCollectionConfig = new MapConfig<PlatformBaseViewModel, PlatformEntity>();
entityCollectionConfig.MembersToIgnore.Add(d => d.EntityType);
DataMapper.RegisterMapConfig(entityCollectionConfig);
var entityConfig = new MapConfig<EntityViewModel, IContent>();
entityConfig.AfterMapAction = (x, y) =>
{
var content = y as IContent;
var model = x as EntityViewModel;
if (content.Entity == null)
{
content.Entity = new PlatformEntity();
}
content.Entity.Url = model.Url;
};
DataMapper.RegisterMapConfig(entityConfig);
_isInitialized = true;
}
internal void RegisterMappings()
{
ConfigureFilterMaps();
ConfigureEntityMaps();
ConfigureAuditMaps();
ConfigureFileMaps(this._imageConverter);
DataMapper.CreateMap<Vocabulary, VocabularyViewModel>().AfterMap((vocabulary, model) =>
{
model.CanEdit = StrixPlatform.User.IsInRole(CmsRoleNames.EDITORROLES);
});
DataMapper.CreateMap<Term, TermViewModel>();
var tagConfig = new MapConfig<IContent, EntityViewModel>();
tagConfig.MembersToMap.Add(d => d.Tags, s => s.Entity.Tags);
DataMapper.RegisterMapConfig(tagConfig);
DataMapper.CreateMap<Comment, CommentViewModel>()
.ForMember(cv => cv.CreatedBy, ce => ce.MapFrom(co => StrixCms.GetUserName(co.CreatedByUserId)))
.ForMember(cv => cv.CreatedByEmail, ce => ce.MapFrom(co => StrixCms.GetUserEmail(co.CreatedByUserId)))
.ForMember(cv => cv.UpdatedBy, ce => ce.MapFrom(co => StrixCms.GetUserName(co.UpdatedByUserId)));
DataMapper.CreateMap<CommentViewModel, Comment>()
.ForMember(co => co.CreatedByUserId, ce => ce.Ignore())
.ForMember(co => co.CreatedOn, ce => ce.Ignore());
DataMapper.CreateMap<File, FileDisplayModel>();
DataMapper.CreateMap<FileDisplayModel, File>().ForAllMembers(mem => mem.Ignore());
DataMapper.CreateMap<MailContentTemplate, MailContentTemplateViewModel>();
ConfigureHtmlEncoding();
}
private static void ConfigureHtmlEncoding()
{
Action<object, object> decodingAction = (x, y) =>
{
object source = x as IContent == null ? x as Comment == null ? null : (object)(x as Comment) : (object)(x as IContent);
var target = y as EntityViewModel == null ? y as CommentViewModel == null ? null : (object)(y as CommentViewModel) : (object)(y as EntityViewModel);
if (source != null && target != null)
{
foreach (var allowHtmlProperty in target.GetType().GetProperties().Where(p => p.HasAttribute<AllowHtmlAttribute>()))
{
var decodedValue = Web.Helpers.HtmlDecode((string)source.GetPropertyValue(allowHtmlProperty.Name), false);
target.SetPropertyValue(allowHtmlProperty.Name, decodedValue);
}
}
};
var decodeEntityConfig = new MapConfig<IContent, EntityViewModel>();
decodeEntityConfig.AfterMapAction = decodingAction;
DataMapper.RegisterMapConfig(decodeEntityConfig);
var decodeCommentConfig = new MapConfig<Comment, CommentViewModel>();
decodeCommentConfig.AfterMapAction = decodingAction;
DataMapper.RegisterMapConfig(decodeCommentConfig);
Action<object, object> encodingAction = (x, y) =>
{
var source = x as EntityViewModel == null ? x as CommentViewModel == null ? null : (object)(x as CommentViewModel) : (object)(x as EntityViewModel);
object target = y as IContent == null ? y as Comment == null ? null : (object)(y as Comment) : (object)(y as IContent);
if (source != null && target != null)
{
foreach (var allowHtmlProperty in source.GetType().GetProperties().Where(p => p.HasAttribute<AllowHtmlAttribute>()))
{
var encodedValue = Web.Helpers.HtmlEncode((string)source.GetPropertyValue(allowHtmlProperty.Name));
target.SetPropertyValue(allowHtmlProperty.Name, encodedValue);
}
}
};
var encodeEntityConfig = new MapConfig<EntityViewModel, IContent>();
encodeEntityConfig.AfterMapAction = encodingAction;
DataMapper.RegisterMapConfig(encodeEntityConfig);
var encodeCommentConfig = new MapConfig<CommentViewModel, Comment>();
encodeCommentConfig.AfterMapAction = encodingAction;
DataMapper.RegisterMapConfig(encodeCommentConfig);
}
public static MapConfig getInstance()
{
if (m_instance == null)
m_instance = new MapConfig();
return m_instance;
}
private static void ConfigureAuditMaps()
{
Action<object, object> auditAction = (x, y) =>
{
var audit = x as IAudit;
var model = y as AuditViewModel;
model.CanEdit = StrixPlatform.User.IsInRole(CmsRoleNames.EDITORROLES) || model.CreatedByUserId == StrixPlatform.User.Id;
model.UpdatedBy = StrixCms.GetUserName(audit.UpdatedByUserId);
model.CreatedBy = StrixCms.GetUserName(audit.CreatedByUserId);
var content = x as IContent;
if (content != null)
{
if (model is EntityViewModel && content.PublishedByUserId.HasValue)
{
((EntityViewModel)model).PublishedBy = StrixCms.GetUserName(content.PublishedByUserId.Value);
}
}
};
var listAuditConfig = new MapConfig<AuditViewModel, AuditViewModel>();
listAuditConfig.AfterMapAction = auditAction;
DataMapper.RegisterMapConfig(listAuditConfig);
var entityAuditConfig = new MapConfig<IContent, AuditViewModel>();
entityAuditConfig.AfterMapAction = auditAction;
DataMapper.RegisterMapConfig(entityAuditConfig);
var auditReturnConfig = new MapConfig<EntityViewModel, IContent>();
auditReturnConfig.MembersToIgnore.Add(d => d.IsCurrentVersion);
auditReturnConfig.MembersToIgnore.Add(d => d.CreatedByUserId);
auditReturnConfig.MembersToIgnore.Add(d => d.CreatedOn);
auditReturnConfig.MembersToIgnore.Add(d => d.UpdatedByUserId);
auditReturnConfig.MembersToIgnore.Add(d => d.UpdatedOn);
DataMapper.RegisterMapConfig(auditReturnConfig);
}