public override ModelNode ReverseSingleHost(object reverseHost, ReverseOptions options)
{
var item = (reverseHost as SecurityRoleReverseHost).HostRole;
var def = new SecurityRoleDefinition();
def.Name = item.Name;
def.Description = item.Description;
var allPermissionNames = Enum.GetNames(typeof(PermissionKind));
foreach (var permissionName in allPermissionNames)
{
var permissionValue = (PermissionKind)Enum.Parse(typeof(PermissionKind), permissionName, true);
if (item.BasePermissions.Has(permissionValue))
{
if (permissionValue != PermissionKind.EmptyMask)
{
def.BasePermissions.Add(permissionName);
}
}
}
return(new SecurityRoleModelNode
{
Options = { RequireSelfProcessing = true },
Value = def
});
}
public override ModelNode ReverseSingleHost(object reverseHost, ReverseOptions options)
{
var typedHost = (reverseHost as ListReverseHost);
var item = typedHost.HostList;
var listContentTypes = item.ContentTypes.ToArray();
var def = new UniqueContentTypeOrderDefinition();
if (item.RootFolder.UniqueContentTypeOrder != null)
{
foreach (var ct in item.RootFolder.UniqueContentTypeOrder.ToArray())
{
var sourceContentType = listContentTypes.FirstOrDefault(c => c.StringId == ct.StringValue);
if (sourceContentType == null)
{
throw new SPMeta2ReverseException(
string.Format("Cannot find list content type by ID:[{0}]", ct.StringValue));
}
def.ContentTypes.Add(new ContentTypeLinkValue
{
ContentTypeName = sourceContentType.Name
});
}
}
return(new UniqueContentTypeOrderModelNode
{
Options = { RequireSelfProcessing = true },
Value = def
});
}
public override ModelNode ReverseSingleHost(object reverseHost, ReverseOptions options)
{
var item = (reverseHost as WebPartPageReverseHost).HostWebPartPageFile;
var context = (reverseHost as WebPartPageReverseHost).HostClientContext;
var def = new WebPartPageDefinition();
def.FileName = item.Name;
def.Title = item.Title;
// always reverse to CustomPageLayout
// we don't know what is the content of the web part page
using (var stream = File.OpenBinaryDirect(
context,
item.ServerRelativeUrl).Stream)
{
def.CustomPageLayout = Encoding.UTF8.GetString(ModuleFileUtils.ReadFully(stream));
}
def.NeedOverride = true;
return(new WebPartPageModelNode
{
Options = { RequireSelfProcessing = true },
Value = def
});
}
public override ModelNode ReverseSingleHost(object reverseHost, ReverseOptions options)
{
var modelNode = new SiteModelNode
{
Options = { RequireSelfProcessing = false },
Value = new SiteDefinition()
};
return(modelNode);
}
public virtual List <ReverseFilterOption> FindReverseFileters(ReverseOptions options, Type definitionType)
{
var filters = options.Options.Where(o =>
o.DefinitionClassFullName == definitionType.FullName &&
o is ReverseFilterOption)
.Select(s => s as ReverseFilterOption)
.ToList();
return(filters);
}
public override ReverseResult Reverse(object modelHost, ReverseOptions options)
{
if (!(modelHost is SiteReverseHost) &&
!(modelHost is WebReverseHost))
{
throw new Exception("modelHost should be either SiteReverseHost or WebReverseHost");
}
return(ReverseInternal(modelHost, options));
}
public override ModelNode ReverseSingleHost(object reverseHost, ReverseOptions options)
{
var typedReverseHost = (reverseHost as FeatureReverseHost);
var item = typedReverseHost.Feature;
FeatureDefinition knownFeature = null;
if (item != null)
{
knownFeature = typedReverseHost.AllKnownFeatures
.FirstOrDefault(f => f.Id == item.DefinitionId);
}
else
{
knownFeature = typedReverseHost.AllKnownFeatures
.FirstOrDefault(f => f.Id == typedReverseHost.FeatureId);
}
if (knownFeature == null)
{
// TODO, warning in logs
// better register a known feature
}
var def = new FeatureDefinition();
if (typedReverseHost.IsSiteLevel)
{
def.Scope = FeatureDefinitionScope.Site;
}
if (typedReverseHost.IsWebLevel)
{
def.Scope = FeatureDefinitionScope.Web;
}
if (item != null)
{
def.Id = item.DefinitionId;
def.Enable = true;
}
else
{
def.Id = typedReverseHost.FeatureId;
def.Enable = false;
}
def.Title = knownFeature != null ? knownFeature.Title : def.Id.ToString();
return(new FeatureModelNode
{
Options = { RequireSelfProcessing = true },
Value = def
});
}
public override ModelNode ReverseSingleHost(object reverseHost, ReverseOptions options)
{
var item = (reverseHost as TaxonomyFieldReverseHost).HostTaxonomyField;
var def = new TaxonomyFieldDefinition();
// TODO
//def.Name = item.Name;
return(new TaxonomyFieldModelNode
{
Options = { RequireSelfProcessing = true },
Value = def
});
}
public override ModelNode ReverseSingleHost(object reverseHost, ReverseOptions options)
{
var typedHost = (reverseHost as ContentTypeLinkReverseHost);
var item = typedHost.HostContentType;
var def = new ContentTypeLinkDefinition();
def.ContentTypeName = item.Name;
return(new ContentTypeLinkModelNode
{
Options = { RequireSelfProcessing = true },
Value = def
});
}
protected virtual ReverseResult ReverseInternal(object modelHost, ReverseOptions options)
{
var result = new ReverseResult();
var context = new ReverseContext
{
ReverseOptions = options,
ReverseHost = modelHost as ReverseHostBase
};
ReverseModel(context);
result.Model = context.RootModelNode;
return(result);
}
public override ModelNode ReverseSingleHost(object reverseHost, ReverseOptions options)
{
var item = (reverseHost as PropertyReverseHost).HostPropertyName;
var itemValue = (reverseHost as PropertyReverseHost).HostPropertyValue;
var def = new PropertyDefinition();
def.Key = item;
def.Value = itemValue;
def.Overwrite = true;
return(new PropertyModelNode
{
Options = { RequireSelfProcessing = true },
Value = def
});
}
public override ModelNode ReverseSingleHost(object reverseHost, ReverseOptions options)
{
var web = (reverseHost as ListReverseHost).HostWeb;
var item = (reverseHost as ListReverseHost).HostList;
var def = new ListDefinition();
def.Title = item.Title;
def.Description = item.Description;
var listServerRelativeUrl = item.RootFolder.ServerRelativeUrl;
if (!web.IsObjectPropertyInstantiated("ServerRelativeUrl"))
{
web.Context.Load(web, w => w.ServerRelativeUrl);
web.Context.ExecuteQueryWithTrace();
}
var webServerRelativeUrl = web.ServerRelativeUrl;
var listWebRelativeUrl = listServerRelativeUrl;
// roort web / ?
if (webServerRelativeUrl.Length > 1)
{
listWebRelativeUrl = listServerRelativeUrl.Replace(webServerRelativeUrl, string.Empty);
}
def.CustomUrl = UrlUtility.RemoveStartingSlash(listWebRelativeUrl);
// TODO, fix for lists based on custom list templates
def.TemplateType = item.BaseTemplate;
def.ContentTypesEnabled = item.ContentTypesEnabled;
def.Hidden = item.Hidden;
//def.OnQuickLaunch = item.OnQuickLaunch;
return(new ListModelNode
{
Options = { RequireSelfProcessing = true },
Value = def
});
}
public override ModelNode ReverseSingleHost(object reverseHost, ReverseOptions options)
{
var typedHost = (reverseHost as TaxonomyTermGroupReverseHost);
var item = typedHost.HostTermGroup;
var def = new TaxonomyTermGroupDefinition();
def.Id = item.Id;
def.Name = item.Name;
// TODO, M2
// https://github.com/SubPointSolutions/spmeta2/issues/827
//def.Descrption = item.Description;
return(new TaxonomyTermGroupModelNode
{
Options = { RequireSelfProcessing = true },
Value = def
});
}
public override ModelNode ReverseSingleHost(object reverseHost, ReverseOptions options)
{
var typedHost = (reverseHost as TaxonomyTermReverseHost);
var item = typedHost.HostTerm;
var def = new TaxonomyTermDefinition();
def.Id = item.Id;
def.Name = item.Name;
def.Description = item.Description;
def.IsAvailableForTagging = item.IsAvailableForTagging;
return(new TaxonomyTermModelNode
{
Options = { RequireSelfProcessing = true },
Value = def
});
}
public override IEnumerable <ReverseHostBase> ReverseHosts(
ReverseHostBase parentHost, ReverseOptions options)
{
var result = new List <TaxonomyTermSetReverseHost>();
var typedHost = parentHost.WithAssertAndCast <TaxonomyTermGroupReverseHost>("reverseHost", value => value.RequireNotNull());
var context = typedHost.HostClientContext;
var site = typedHost.HostSite;
TermCollection items = null;
if (parentHost is TaxonomyTermReverseHost)
{
items = (parentHost as TaxonomyTermReverseHost).HostTerm.Terms;
}
else if (parentHost is TaxonomyTermSetReverseHost)
{
items = (parentHost as TaxonomyTermSetReverseHost).HostTermSet.Terms;
}
else
{
throw new SPMeta2ReverseException(
string.Format("Unsupported host:[{0}]", parentHost.GetType()));
}
context.Load(items);
context.ExecuteQueryWithTrace();
result.AddRange(ApplyReverseFilters(items, options).ToArray().Select(i =>
{
return(ModelHostBase.Inherit <TaxonomyTermReverseHost>(parentHost, h =>
{
h.HostTerm = i;
}));
}));
return(result);
}
