public override void Map(string inputLine, MapperContext context)
{
try
{
var doc = XDocument.Parse(inputLine);
var sensors =
doc.Descendants("sensor")
.Select(
element => new
{
name = (string)element.Attribute("name"),
value = element.Value
});
foreach (var sensor in sensors)
{
context.EmitKeyValue(sensor.name, sensor.value);
}
}
catch (Exception x)
{
context.EmitLine(x.ToString());
}
}
// Gets the total number of purchases made by users in North America & in Europe.
// The input is the output from the AggregatePurchaseMapper job (which map reduced the 'clickstearm' data file).
// In format........'Country \t Number of Purchases \t % of the purchases made by New users'
// E.g. 'France 5 20'
public override void Map(string inputLine, MapperContext context)
{
var dataRow = inputLine.Split('\t');
if (dataRow.Count() == 3)
{
var country = dataRow[0];
int numPurchases;
int percentNew;
if (int.TryParse(dataRow[1], out numPurchases) && int.TryParse(dataRow[2], out percentNew))
{
var continent = string.Empty;
if (_europeanCountries.Contains(country))
{
continent = "Europe";
}
else if (_northAmericanCountries.Contains(country))
{
continent = "North America";
}
if (!string.IsNullOrEmpty(continent))
{
var numNewUserPurchases = numPurchases * percentNew / 100;
context.EmitKeyValue(continent, numNewUserPurchases.ToString(CultureInfo.InvariantCulture));
}
}
}
}
public override void Map(string inputLine, MapperContext context)
{
var matches = commaSplit.Matches(inputLine);
//Hadoop is semi-structured, meaning that we do not need every row to match
//our expected structure. This is a simplistic check, but given a more polyglot
//data set, we could filter out unexpected rows or perform more complex filtering.
if (matches == null || matches.Count != 6)
{
//If this were a production data set, I would think about logging bad rows
//but because this is a demo, I just want to return without passing anything
//to be reduced.
return;
}
//Trim off any leading comma or surrounding quotation marks.
string key = matches[1].Value.TrimStart(',').Trim('\"');
//We don't want to return the header row.
if (key == "LCR DESC")
{
return;
}
//The Map function returns a set of key-value pairs.
//The key in this case is the specific crime, and our value
//is "1" (which we will use to get a count).
context.EmitKeyValue(key, value);
}
public override void Map(string inputLine, MapperContext context)
{
//Step to Identify the Practice or Prescription data set
//Using the SDK, tried to use the MapperContext.InputFileName property: it is always empty
//So decided to use items count of each datasets
//Items count 8 for practice and Items count 9 for prescription
char[] delimiterChars = { ',' };
//split up the passed in line
string[] individualItems = inputLine.Trim().Split(delimiterChars);
if (individualItems.Count() == 9)
{
Prescription prescription = reader.ExtractPrescriptionsFromCsvLineFormat(inputLine);
if (String.IsNullOrWhiteSpace(prescription.PracticeId)) { return; } //Ignore, practise name cannot be null
//Filter by peppermint oil
if (prescription.BNFName.ToLower() != "peppermint oil") { return; } //Ignore, if filtor not matched
context.EmitKeyValue(prescription.BNFName, prescription.ActualCost.ToString("0.00"));
}
}
public override void Map(string inputLine, MapperContext context)
{
var delivery = new Delivery();
double result = 0.0;
context.Log("MAPPER:::START");
context.Log(inputLine);
context.Log("UTF-8: " + Encoding.UTF8.GetBytes(inputLine).Length);
context.Log("ASCII: " + Encoding.ASCII.GetBytes(inputLine).Length);
// Read the incoming string as a Thrift Binary serialized object
var inputStream = new MemoryStream(Encoding.UTF8.GetBytes(inputLine));
using (var transport = new TStreamTransport(inputStream, null))
{
delivery.Read(new TBinaryProtocol(transport));
context.Log("MAPPER:::AFTER_READ");
// Get the driven kilometers from the vehicle's odometer sensor
var sensorData = delivery.Vehicle.SensorHistory;
var minOdo = sensorData.Min(d => d.OdoMeter);
var maxOdo = sensorData.Max(d => d.OdoMeter);
result = maxOdo - minOdo;
context.Log("MAPPER:::BEFORE_STREAM_CLOSE");
}
context.Log("MAPPER:::AFTER_STREAM_CLOSE");
// Emit the vehicle id, and the driven kilometers.
if (result > 0.1)
{
context.EmitKeyValue(delivery.Vehicle.VehicleId, result.ToString(CultureInfo.InvariantCulture));
}
context.Log("MAPPER:::END");
}
public override void Map(string inputLine, MapperContext context)
{
//interpret the incoming line as an integer value
var value = int.Parse(inputLine);
//determine whether value is even or odd
string key = value%2 == 0 ? "even" : "odd";
//output key assignment with value
context.EmitKeyValue(key, value.ToString());
}
public override void Map(string inputLine, MapperContext context)
{
// The odometer is on index 2
var parts = inputLine.Split('\t');
var id = parts[0];
var kilometers = parts[2];
context.EmitKeyValue(id, kilometers);
}
public override void Map(string inputLine, MapperContext context)
{
string[] terms = inputLine.Split('\t');
// add a sanity check in case we have a data quality issue
if (terms.Length != 6) return;
// get the country part out
string country = terms[3];
context.EmitKeyValue(country, "1");
}
public override void Map(string inputLine, MapperContext context)
{
string[] inputValues = inputLine.Split(',');
//Pulls all responses that link to the id of this question
if (inputValues[1].Trim() == "10001")
{
string ip = inputValues[0].Trim();
string country = IpAddressResolver.Resolve(ip);
context.EmitKeyValue(country, inputValues[2]);
}
}
public override void Map(string inputLine, MapperContext context)
{
var dataRow = inputLine.Split('\t');
if (dataRow.Count() == 4)
{
var userId = dataRow[1];
var rating = dataRow[2];
var movieId = dataRow[3];
context.EmitKeyValue(userId, StringUtility.GetAsTabbedString(new[]{ movieId, rating}));
}
}
public override void Map(string inputLine, MapperContext context)
{
string[] fields = inputLine.Split(',');
string horse = fields[0];
string jockey = fields[1];
string course = fields[2];
string stats = GetStatsForHorseJockeyCourse(
horse,
jockey,
course);
context.EmitKeyValue(horse, stats);
}
public override void Map(string inputLine, MapperContext context)
{
//example input: Hello, Andy
if (!inputLine.StartsWith("Hello, "))
{
context.Log(string.Format("The inputLine {0} is not in the correct format", inputLine));
context.IncrementCounter("RecoverableError", "InputFormatIncorrect", 1);
return;
}
var key = inputLine.Substring(7);
if (key.EndsWith(".")) key = key.Trim('.');
context.EmitKeyValue(key, "1");//we are going to count instances, the value is irrelevant
}
public void should_inherit_base_beforemap()
{
// arrange
var source = new Class {Prop = "test"};
var context = new MapperContext();
context.CreateMap<BaseClass, BaseDto>()
.BeforeMap((s, d) => d.DifferentProp = s.Prop)
.Include<Class, Dto>();
context.CreateMap<Class, Dto>();
// act
var dest = context.Engine.Map<Class, Dto>(source);
// assert
"test".ShouldEqual(dest.DifferentProp);
}
// Gets the total number of purchases in each country across the 4 days & the % of these purchases made by new users.
// Each data row in 'clickstearm' data file is in the format...
// 'DateTime of Hit \t ProductId \t VisitorType \t Country of Request \t Referrer \t Action'
// E.g. 01/03/2013 18:51:31 159822 Regular USA Adword Purchase
public override void Map(string inputLine, MapperContext context)
{
var dataRow = inputLine.Split('\t');
if (dataRow.Count() == 6)
{
var visitorType = dataRow[2];
var country = dataRow[3];
var action = dataRow[5];
if (action == "Purchase")
{
context.IncrementCounter("HitMissProgress", "PurchaseFound", 1);
context.EmitKeyValue(country, visitorType);
}
context.IncrementCounter("HitMissProgress", "PurchaseNotFound", 1);
}
}
public override void Map(string inputLine, MapperContext context)
{
var matches = commaSplit.Matches(inputLine);
//Hadoop is semi-structured, meaning that we do not need every row to match
//our expected structure. This is a simplistic check, but given a more polyglot
//data set, we could filter out unexpected rows or perform more complex filtering.
if (matches == null || matches.Count != 6)
{
//If this were a production data set, I would think about logging bad rows
//but because this is a demo, I just want to return without passing anything
//to be reduced.
return;
}
//Trim off any leading comma or surrounding quotation marks.
string key = matches[5].Value.TrimStart(',').Trim('\"').Trim('(').Trim(')');
//We don't want to return the header row.
if (key == "LOCATION")
{
return;
}
//At this point, we have coordinates which look like
//35.776238687249744, -78.6246378053371
//We want to solve to 3 places after the decimal point to
//get a better idea of "neighborhood"/area-level crime.
var keyvals = key.Split(',');
if (keyvals.Length != 2)
{
return;
}
key = keyvals[0].Trim(' ').Substring(0, keyvals[0].IndexOf('.') + 4)
+ ", " + keyvals[1].Trim(' ').Substring(0, keyvals[1].IndexOf('.') + 3);
//The Map function returns a set of key-value pairs.
//The key in this case is the specific crime, and our value
//is "1" (which we will use to get a count).
context.EmitKeyValue(key, value);
}
public override void Map(string inputLine, MapperContext context)
{
var ofertas = ServiceHelper.Deserialize<OffertResult>(inputLine);
foreach (var oferta in ofertas.offers.Where(x => x.category != null && !String.IsNullOrEmpty(x.category.value)))
{
if (oferta.province != null && !String.IsNullOrEmpty(oferta.province.value))
{
var fecha = String.Format("{0}:00:00", Convert.ToDateTime(oferta.published).Hour);
var provincia = Province.DepurarProvincia(oferta.province.value);
var linea = String.Format("{0};{1};{2}" + Environment.NewLine,
oferta.category.value,
provincia,
fecha);
context.EmitKeyValue(linea, "1");
}
}
}
public override void Map(string inputLine, MapperContext context)
{
if (inputLine.Contains(";"))
{
var array = inputLine.Split(';');
if (array.Length >= 3)
{
var provincia = Province.DepurarProvincia(array[2]);
var fecha = String.Format("{0}:00:00",
Convert.ToDateTime(array[1], new CultureInfo("es-es")).Hour);
var linea = String.Format("{0};{1};{2}" + Environment.NewLine,
array[0],
provincia,
fecha);
context.EmitKeyValue(linea, "1");
}
}
}
public override void Map(string inputLine, MapperContext context)
{
//Step to Identify the Practice or Prescription data set
//Using the SDK, tried to use the MapperContext.InputFileName property: it is always empty
//So decided to use items count of each datasets
//Items count 8 for practice and Items count 9 for prescription
char[] delimiterChars = { ',' };
//split up the passed in line
string[] individualItems = inputLine.Trim().Split(delimiterChars);
if (individualItems.Count() == 8)
{
Practices practice = reader.ExtractPracticesFromCsvLineFormat(inputLine);
if (String.IsNullOrWhiteSpace(practice.ReferenceId)) { return; } //Ignore, practise name cannot be null
if (String.IsNullOrWhiteSpace(practice.Name)) { return; } //Ignore, practise name cannot be null
context.EmitKeyValue("UK", Convert.ToString(practice.ReferenceId));
}
}
private IEnumerable <DataTypeConfigurationFieldDisplay> MapPreValues(IDataEditor source, MapperContext context)
{
// this is a new data type, initialize default configuration
// get the configuration editor,
// get the configuration fields and map to UI,
// get the configuration default values and map to UI
var configurationEditor = source.GetConfigurationEditor();
var fields = context.MapEnumerable <ConfigurationField, DataTypeConfigurationFieldDisplay>(configurationEditor.Fields);
var defaultConfiguration = configurationEditor.DefaultConfiguration;
if (defaultConfiguration != null)
{
MapConfigurationFields(null, fields, defaultConfiguration);
}
return(fields);
}
private IEnumerable <PropertyEditorBasic> MapAvailableEditors(IDataType source, MapperContext context)
{
var properties = _propertyEditors
.Where(x => !x.IsDeprecated || _contentSettings.ShowDeprecatedPropertyEditors || source.EditorAlias == x.Alias)
.OrderBy(x => x.Name);
return(context.MapEnumerable <IDataEditor, PropertyEditorBasic>(properties));
}
internal MappingConfigStartingPoint(MapperContext mapperContext)
{
_configInfo = new MappingConfigInfo(mapperContext);
}
public UserProfile GetCreator(IContent source, MapperContext context)
{
var profile = source.GetWriterProfile(_userService);
return(profile == null ? null : context.Map <IProfile, UserProfile>(profile));
}
private static PropertyGroup MapSaveGroup <TPropertyType>(PropertyGroupBasic <TPropertyType> sourceGroup,
IEnumerable <PropertyGroup> destOrigGroups, MapperContext context)
where TPropertyType : PropertyTypeBasic
{
PropertyGroup destGroup;
if (sourceGroup.Id > 0)
{
// update an existing group
// ensure it is still there, then map/update
destGroup = destOrigGroups.FirstOrDefault(x => x.Id == sourceGroup.Id);
if (destGroup != null)
{
context.Map(sourceGroup, destGroup);
return(destGroup);
}
// force-clear the ID as it does not match anything
sourceGroup.Id = 0;
}
// insert a new group, or update an existing group that has
// been deleted in the meantime and we need to re-create
// map/create
destGroup = context.Map <PropertyGroup>(sourceGroup);
return(destGroup);
}
public override void Map(string inputLine, MapperContext context)
{
var data = inputLine.Split('\t');
//countrycode --- name,value,originalValue
context.EmitKeyValue(data[0], data[1] + '\t' + data[2] + '\t' + data[3] + '\t' + data[4]);
}
// Umbraco.Code.MapAll -Alias
private void Map(IContent source, ContentItemBasic <ContentPropertyBasic> target, MapperContext context)
{
target.ContentTypeId = source.ContentType.Id;
target.ContentTypeAlias = source.ContentType.Alias;
target.CreateDate = source.CreateDate;
target.Edited = source.Edited;
target.Icon = source.ContentType.Icon;
target.Id = source.Id;
target.Key = source.Key;
target.Name = GetName(source, context);
target.Owner = _commonMapper.GetOwner(source, context);
target.ParentId = source.ParentId;
target.Path = source.Path;
target.Properties = context.MapEnumerable <Property, ContentPropertyBasic>(source.Properties);
target.SortOrder = source.SortOrder;
target.State = _basicStateMapper.Map(source, context);
target.Trashed = source.Trashed;
target.Udi = Udi.Create(source.Blueprint ? Constants.UdiEntityType.DocumentBlueprint : Constants.UdiEntityType.Document, source.Key);
target.UpdateDate = GetUpdateDate(source, context);
target.Updater = _commonMapper.GetCreator(source, context);
target.VariesByCulture = source.ContentType.VariesByCulture();
}
public override void Initialize(MapperContext context)
{
reader = new PracticeLineReader();
base.Initialize(context);
}
public override void Map(string inputLine, MapperContext context)
{
var delivery = SerializationHelper.Deserialize<Delivery>(inputLine);
//TODO
}
public override void Initialize(MapperContext context)
{
practiceLinereader = new PracticeLineReader();
prescriptionLinereader = new PrescriptionLineReader();
base.Initialize(context);
}
public override void Map(string inputLine, MapperContext context)
{
var data = inputLine.Split('\t');
context.EmitKeyValue((-Double.Parse(data[1])).ToString(), inputLine);//order by value descending
}
// Umbraco.Code.MapAll -Value
private static void Map(ConfigurationField source, DataTypeConfigurationFieldDisplay target, MapperContext context)
{
target.Config = source.Config;
target.Description = source.Description;
target.HideLabel = source.HideLabel;
target.Key = source.Key;
target.Name = source.Name;
target.View = source.View;
}
// Umbraco.Code.MapAll
private static void Map(Section source, ManifestSection target, MapperContext context)
{
target.Alias = source.Alias;
target.Name = source.Name;
}
internal PlanTargetSelector(MapperContext mapperContext)
{
_mapperContext = mapperContext;
}
public void TestMerge()
{
var context1 = new MapperContext();
var context2 = new MapperContext();
}
// Umbraco.Code.MapAll
private static void Map(IContent source, ContentPropertyCollectionDto target, MapperContext context)
{
target.Properties = context.MapEnumerable <Property, ContentPropertyDto>(source.Properties);
}
// no MapAll - uses the IContentTypeBase map method, which has MapAll
private static void Map(IContentTypeComposition source, ContentTypeBasic target, MapperContext context)
{
Map(source, target, Constants.UdiEntityType.MemberType);
}
// no MapAll - relies on the non-generic method
private void MapTypeToDisplayBase <TSource, TSourcePropertyType, TTarget, TTargetPropertyType>(TSource source,
TTarget target, MapperContext context)
where TSource : ContentTypeSave <TSourcePropertyType>
where TSourcePropertyType : PropertyTypeBasic
where TTarget : ContentTypeCompositionDisplay <TTargetPropertyType>
where TTargetPropertyType : PropertyTypeDisplay
{
MapTypeToDisplayBase(source, target);
target.Groups =
context
.MapEnumerable <PropertyGroupBasic <TSourcePropertyType>, PropertyGroupDisplay <TTargetPropertyType> >(
source.Groups);
}
public override void Map(string inputLine, MapperContext context)
{
//split line on tabs
try
{
var s = JsonConvert.DeserializeObject<Roo>(inputLine);
//get year observed
if (string.IsNullOrEmpty(s.prepTime))
{
s.prepTime = "Un";
}
//get ufo type
if (string.IsNullOrEmpty(s.name))
{
s.name = "nul";
}
context.EmitKeyValue(s.prepTime, s.name);
//send output
}
catch (InvalidCastException ex)
{
context.EmitKeyValue("error", "roor");
}
}
private static IPropertyType MapSaveProperty(PropertyTypeBasic sourceProperty,
IEnumerable <IPropertyType> destOrigProperties, MapperContext context)
{
IPropertyType destProperty;
if (sourceProperty.Id > 0)
{
// updating an existing property
// ensure it is still there, then map/update
destProperty = destOrigProperties.FirstOrDefault(x => x.Id == sourceProperty.Id);
if (destProperty != null)
{
context.Map(sourceProperty, destProperty);
return(destProperty);
}
// force-clear the ID as it does not match anything
sourceProperty.Id = 0;
}
// insert a new property, or update an existing property that has
// been deleted in the meantime and we need to re-create
// map/create
destProperty = context.Map <IPropertyType>(sourceProperty);
return(destProperty);
}
// no MapAll - take care
private void Map(MediaTypeSave source, MediaTypeDisplay target, MapperContext context)
{
MapTypeToDisplayBase <MediaTypeSave, PropertyTypeBasic, MediaTypeDisplay, PropertyTypeDisplay>(source, target, context);
}
public override void Map(string inputLine, MapperContext context)
{
int i = 0;
SingleTweet Tweets = JsonConvert.DeserializeObject <SingleTweet>(StripHTML(inputLine));;
var MaxSource = from k in Tweets.statuses group k by k.source into r select r.Max(n => n.source);
var SourceNotNullCount = (from k in Tweets.statuses where k.source != null select k.source).Count();
var CountryNotNullCount = (from k in Tweets.statuses where k.place != null select k.place).Count();
//"Fri Apr 22 16:26:21 +0000 2016"
var CreatedAt = (from k in Tweets.statuses group k by k.created_at into r select r.Key);
Dictionary <long, int> LDates = new Dictionary <long, int>();
foreach (var item in CreatedAt)
{
var ds = item.Split(' ');
var dsT = ds[3].Split(':');
DateTime d = new DateTime(int.Parse(ds[5]), 4, int.Parse(ds[2]), int.Parse(dsT[0]), int.Parse(dsT[1]), int.Parse(dsT[2]));
var cd = (from k in Tweets.statuses where k.created_at == item select k.created_at).Count();
try
{
LDates.Add(d.Ticks, cd);
}
catch (Exception)
{
}
}
var MaxUser = (from k in Tweets.statuses group k by k.user.name into r select r.Max(n => n.user.name)).Take(10);
var MaxCountry = (from k in Tweets.statuses where k.place != null group k by k.place into r select r.Max(n => n.place));
var RetweetSum = (from k in Tweets.statuses select k.retweet_count).Sum();
var FavouriteSum = (from k in Tweets.statuses select k.favorite_count).Sum();
var tweetsCount = (from k in Tweets.statuses select k).Count();
dynamic a = MaxCountry.ToList();
dynamic ac = MaxSource.ToList();
List <string> Countries = new List <string>();
List <string> Sources = new List <string>();
foreach (var item in a)
{
string[] Sp = Regex.Split(item.ToString(), "\"country\":");
string r = Sp[1].Replace("\"", "");
r = r.Remove(Sp[1].IndexOf(",")).ToString().Trim();
Countries.Add(r.Trim(',', ' ').Trim());
}
foreach (var item in ac)
{
Sources.Add(item.Trim());
}
Dictionary <string, double> CountryCounter = new Dictionary <string, double>();
Dictionary <string, double> SourceCounter = new Dictionary <string, double>();
foreach (var c in Countries)
{
var CountCountry = (from k in Countries where k == c select k).Count();
double y = ((double)CountCountry / (double)CountryNotNullCount) * 100;
try
{
CountryCounter.Add(c, Math.Round(y, 2));
}
catch (Exception)
{
}
}
foreach (var c in Sources)
{
var CountCountry = (from k in Sources where k == c select k).Count();
double y = ((double)CountCountry / (double)SourceNotNullCount) * 100;
try
{
SourceCounter.Add(c, Math.Round(y, 2));
}
catch (Exception)
{
}
}
var uCountry = CountryCounter;
var uSources = SourceCounter.Distinct().Take(10);
List <string> Finish = new List <string>();
Finish.Add(JsonConvert.SerializeObject(MaxUser));
Finish.Add(JsonConvert.SerializeObject(uCountry));
Finish.Add(JsonConvert.SerializeObject(uSources));
Finish.Add(JsonConvert.SerializeObject(LDates.Take(100)));
Finish.Add(JsonConvert.SerializeObject(RetweetSum));
Finish.Add(JsonConvert.SerializeObject(FavouriteSum));
Finish.Add(JsonConvert.SerializeObject(tweetsCount));
var json = JsonConvert.SerializeObject(Finish);
context.EmitKeyValue(json, i.ToString());
}
// Umbraco.Code.MapAll -CreateDate -UpdateDate -DeleteDate -Key -PropertyTypes
private static void Map(PropertyGroupBasic <MemberPropertyTypeBasic> source, PropertyGroup target, MapperContext context)
{
if (source.Id > 0)
{
target.Id = source.Id;
}
target.Key = source.Key;
target.Type = source.Type;
target.Name = source.Name;
target.Alias = source.Alias;
target.SortOrder = source.SortOrder;
}
// Umbraco.Code.MapAll -Edited -Updater -Alias
private void Map(IMedia source, ContentItemBasic <ContentPropertyBasic> target, MapperContext context)
{
target.ContentTypeId = source.ContentType.Id;
target.ContentTypeAlias = source.ContentType.Alias;
target.CreateDate = source.CreateDate;
target.Icon = source.ContentType.Icon;
target.Id = source.Id;
target.Key = source.Key;
target.Name = source.Name;
target.Owner = _commonMapper.GetOwner(source, context);
target.ParentId = source.ParentId;
target.Path = source.Path;
target.Properties = context.MapEnumerable <Property, ContentPropertyBasic>(source.Properties);
target.SortOrder = source.SortOrder;
target.State = null;
target.Trashed = source.Trashed;
target.Udi = Udi.Create(Constants.UdiEntityType.Media, source.Key);
target.UpdateDate = source.UpdateDate;
target.VariesByCulture = source.ContentType.VariesByCulture();
}
// no MapAll - take care
private void Map(MediaTypeSave source, IMediaType target, MapperContext context)
{
MapSaveToTypeBase <MediaTypeSave, PropertyTypeBasic>(source, target, context);
MapComposition(source, target, alias => _mediaTypeService.Get(alias));
}
private IEnumerable <DataTypeConfigurationFieldDisplay> MapPreValues(IDataType dataType, MapperContext context)
{
// in v7 it was apparently fine to have an empty .EditorAlias here, in which case we would map onto
// an empty fields list, which made no sense since there would be nothing to map to - and besides,
// a datatype without an editor alias is a serious issue - v8 wants an editor here
if (string.IsNullOrWhiteSpace(dataType.EditorAlias) || !_propertyEditors.TryGet(dataType.EditorAlias, out var editor))
{
throw new InvalidOperationException($"Could not find a property editor with alias \"{dataType.EditorAlias}\".");
}
var configurationEditor = editor.GetConfigurationEditor();
var fields = context.MapEnumerable <ConfigurationField, DataTypeConfigurationFieldDisplay>(configurationEditor.Fields);
var configurationDictionary = configurationEditor.ToConfigurationEditor(dataType.Configuration);
MapConfigurationFields(dataType, fields, configurationDictionary);
return(fields);
}
// no MapAll - uses the IContentTypeBase map method, which has MapAll private void Map(IMemberType source, ContentTypeBasic target, MapperContext context) => Map(source, target, Constants.UdiEntityType.MemberType);
// Umbraco.Code.MapAll
private static void Map(IDataEditor source, PropertyEditorBasic target, MapperContext context)
{
target.Alias = source.Alias;
target.Icon = source.Icon;
target.Name = source.Name;
}
// no MapAll - take care
private void Map(MemberTypeSave source, MemberTypeDisplay target, MapperContext context) =>
MapTypeToDisplayBase <MemberTypeSave, MemberPropertyTypeBasic, MemberTypeDisplay, MemberPropertyTypeDisplay>(
source, target, context);
public PlanTargetSelector(MapperContext mapperContext, IQueryable <TSource> exampleQueryable)
: this(mapperContext)
{
_exampleQueryable = exampleQueryable;
}
// Umbraco.Code.MapAll -ContentTypeId -ParentTabContentTypes -ParentTabContentTypeNames
private static void Map(PropertyGroupBasic <MemberPropertyTypeBasic> source,
PropertyGroupDisplay <MemberPropertyTypeDisplay> target, MapperContext context)
{
target.Inherited = source.Inherited;
if (source.Id > 0)
{
target.Id = source.Id;
}
target.Key = source.Key;
target.Type = source.Type;
target.Name = source.Name;
target.Alias = source.Alias;
target.SortOrder = source.SortOrder;
target.Properties =
context.MapEnumerable <MemberPropertyTypeBasic, MemberPropertyTypeDisplay>(source.Properties);
}
public override void Map(IProperty originalProp, ContentPropertyDisplay dest, MapperContext context)
{
base.Map(originalProp, dest, context);
var config = DataTypeService.GetDataType(originalProp.PropertyType.DataTypeId).Configuration;
// TODO: IDataValueEditor configuration - general issue
// GetValueEditor() returns a non-configured IDataValueEditor
// - for richtext and nested, configuration determines HideLabel, so we need to configure the value editor
// - could configuration also determines ValueType, everywhere?
// - does it make any sense to use a IDataValueEditor without configuring it?
// configure the editor for display with configuration
var valEditor = dest.PropertyEditor.GetValueEditor(config);
//set the display properties after mapping
dest.Alias = originalProp.Alias;
dest.Description = originalProp.PropertyType.Description;
dest.Label = originalProp.PropertyType.Name;
dest.HideLabel = valEditor.HideLabel;
dest.LabelOnTop = originalProp.PropertyType.LabelOnTop;
//add the validation information
dest.Validation.Mandatory = originalProp.PropertyType.Mandatory;
dest.Validation.MandatoryMessage = originalProp.PropertyType.MandatoryMessage;
dest.Validation.Pattern = originalProp.PropertyType.ValidationRegExp;
dest.Validation.PatternMessage = originalProp.PropertyType.ValidationRegExpMessage;
if (dest.PropertyEditor == null)
{
//display.Config = PreValueCollection.AsDictionary(preVals);
//if there is no property editor it means that it is a legacy data type
// we cannot support editing with that so we'll just render the readonly value view.
dest.View = "views/propertyeditors/readonlyvalue/readonlyvalue.html";
}
else
{
//let the property editor format the pre-values
dest.Config = dest.PropertyEditor.GetConfigurationEditor().ToValueEditor(config);
dest.View = valEditor.View;
}
//Translate
dest.Label = _textService.UmbracoDictionaryTranslate(_cultureDictionary, dest.Label);
dest.Description = _textService.UmbracoDictionaryTranslate(_cultureDictionary, dest.Description);
}
// Umbraco.Code.MapAll -Editor -View -Config -ContentTypeId -ContentTypeName -Locked -DataTypeIcon -DataTypeName
private static void Map(MemberPropertyTypeBasic source, MemberPropertyTypeDisplay target, MapperContext context)
{
target.Alias = source.Alias;
target.AllowCultureVariant = source.AllowCultureVariant;
target.AllowSegmentVariant = source.AllowSegmentVariant;
target.DataTypeId = source.DataTypeId;
target.DataTypeKey = source.DataTypeKey;
target.Description = source.Description;
target.GroupId = source.GroupId;
target.Id = source.Id;
target.Inherited = source.Inherited;
target.IsSensitiveData = source.IsSensitiveData;
target.Label = source.Label;
target.MemberCanEditProperty = source.MemberCanEditProperty;
target.MemberCanViewProperty = source.MemberCanViewProperty;
target.SortOrder = source.SortOrder;
target.Validation = source.Validation;
target.LabelOnTop = source.LabelOnTop;
}
private DateTime?GetScheduledDate(IContent source, ContentScheduleAction action, MapperContext context)
{
var culture = context.GetCulture() ?? string.Empty;
var schedule = source.ContentSchedule.GetSchedule(culture, action);
return(schedule.FirstOrDefault()?.Date); // take the first, it's ordered by date
}
// Umbraco.Code.MapAll -CreatorId -Level -SortOrder -Variations
// Umbraco.Code.MapAll -CreateDate -UpdateDate -DeleteDate
// Umbraco.Code.MapAll -ContentTypeComposition (done by AfterMapSaveToType)
private static void MapSaveToTypeBase <TSource, TSourcePropertyType>(TSource source,
IContentTypeComposition target, MapperContext context)
where TSource : ContentTypeSave <TSourcePropertyType>
where TSourcePropertyType : PropertyTypeBasic
{
// TODO: not so clean really
var isPublishing = target is IContentType;
var id = Convert.ToInt32(source.Id);
if (id > 0)
{
target.Id = id;
}
target.Alias = source.Alias;
target.Description = source.Description;
target.Icon = source.Icon;
target.IsContainer = source.IsContainer;
target.IsElement = source.IsElement;
target.Key = source.Key;
target.Name = source.Name;
target.ParentId = source.ParentId;
target.Path = source.Path;
target.Thumbnail = source.Thumbnail;
target.AllowedAsRoot = source.AllowAsRoot;
target.AllowedContentTypes = source.AllowedContentTypes.Select((t, i) => new ContentTypeSort(t, i));
if (!(target is IMemberType))
{
target.SetVariesBy(ContentVariation.Culture, source.AllowCultureVariant);
target.SetVariesBy(ContentVariation.Segment, source.AllowSegmentVariant);
}
// handle property groups and property types
// note that ContentTypeSave has
// - all groups, inherited and local; only *one* occurrence per group *name*
// - potentially including the generic properties group
// - all properties, inherited and local
//
// also, see PropertyTypeGroupResolver.ResolveCore:
// - if a group is local *and* inherited, then Inherited is true
// and the identifier is the identifier of the *local* group
//
// IContentTypeComposition AddPropertyGroup, AddPropertyType methods do some
// unique-alias-checking, etc that is *not* compatible with re-mapping everything
// the way we do it here, so we should exclusively do it by
// - managing a property group's PropertyTypes collection
// - managing the content type's PropertyTypes collection (for generic properties)
// handle actual groups (non-generic-properties)
PropertyGroup[] destOrigGroups = target.PropertyGroups.ToArray(); // local groups
IPropertyType[] destOrigProperties = target.PropertyTypes.ToArray(); // all properties, in groups or not
var destGroups = new List <PropertyGroup>();
PropertyGroupBasic <TSourcePropertyType>[] sourceGroups =
source.Groups.Where(x => x.IsGenericProperties == false).ToArray();
var sourceGroupParentAliases = sourceGroups.Select(x => x.GetParentAlias()).Distinct().ToArray();
foreach (PropertyGroupBasic <TSourcePropertyType> sourceGroup in sourceGroups)
{
// get the dest group
PropertyGroup destGroup = MapSaveGroup(sourceGroup, destOrigGroups, context);
// handle local properties
IPropertyType[] destProperties = sourceGroup.Properties
.Where(x => x.Inherited == false)
.Select(x => MapSaveProperty(x, destOrigProperties, context))
.ToArray();
// if the group has no local properties and is not used as parent, skip it, ie sort-of garbage-collect
// local groups which would not have local properties anymore
if (destProperties.Length == 0 && !sourceGroupParentAliases.Contains(sourceGroup.Alias))
{
continue;
}
// ensure no duplicate alias, then assign the group properties collection
EnsureUniqueAliases(destProperties);
destGroup.PropertyTypes = new PropertyTypeCollection(isPublishing, destProperties);
destGroups.Add(destGroup);
}
// ensure no duplicate name, then assign the groups collection
EnsureUniqueAliases(destGroups);
target.PropertyGroups = new PropertyGroupCollection(destGroups);
// because the property groups collection was rebuilt, there is no need to remove
// the old groups - they are just gone and will be cleared by the repository
// handle non-grouped (ie generic) properties
PropertyGroupBasic <TSourcePropertyType> genericPropertiesGroup =
source.Groups.FirstOrDefault(x => x.IsGenericProperties);
if (genericPropertiesGroup != null)
{
// handle local properties
IPropertyType[] destProperties = genericPropertiesGroup.Properties
.Where(x => x.Inherited == false)
.Select(x => MapSaveProperty(x, destOrigProperties, context))
.ToArray();
// ensure no duplicate alias, then assign the generic properties collection
EnsureUniqueAliases(destProperties);
target.NoGroupPropertyTypes = new PropertyTypeCollection(isPublishing, destProperties);
}
// because all property collections were rebuilt, there is no need to remove
// some old properties, they are just gone and will be cleared by the repository
}
// no MapAll - uses the IContentTypeBase map method, which has MapAll
private static void Map(IMediaType source, ContentTypeBasic target, MapperContext context)
{
Map(source, target, Constants.UdiEntityType.MediaType);
}
public override void Map(string inputLine, MapperContext context)
{
var PROCESSED_YEAR = 2007;
var data = ExtractValueFromLine(inputLine);
if (data.CountryName == "Country Name")
{
return;
}
if (data.YearValues.ContainsKey(PROCESSED_YEAR))
{
var trend = ComputeTrend(data.YearValues, PROCESSED_YEAR);
context.EmitKeyValue(data.IndicatorCode, data.CountryCode + '\t' + data.CountryName + '\t' + trend + '\t' + data.YearValues[PROCESSED_YEAR]);
}
}
