is there a method to create a list from template or existing list?

[kongmengfei]

i am trying to use pnpcore sdk to create and provision a new site , and will create some custom lists. is there any way to create lists from template or existing list on another site? (i use C#)

thanks

[jansenbe]

@kongmengfei : no, we don't have that option in PnP Core SDK.

[sachinsatav]

@jansenbe Has there been any change in this functionality? We use PnPCore SDK and we need to create a custom list which has too many complex computational columns and data with lots of rows. Creating those lists using code is proving to be quite difficult with all that json for column.
So is there anyway we can create a list from existing list? If not, when can we expect this feature? Thank you.

[DmitriyVdE]

I think you can just go to some site's site contents, create a new list based on another list and even choose lists from other sites. Otherwise you'll have to do this through provisioning.

[DmitriyVdE]

You can use the PnP.Framework provisioning engine (available in PnP.Core) to create templates and apply them to sites.

You'll have to first convert you PnPContext to a ClientContext (interop) which gives you access to the PnP.Framework functions after which you can use the provisioning engine.

Also, here is the most recent provisioning schema documentation.

[sachinsatav]

Hi @DmitriyVdE thanks for your response. I was hoping to keep list structure away from code so that future change in list templates, doesn't require change in code. So the idea I was going after is below -

1. Create different lists in root site ( with default data)
2. My function would receive a message with information about which list template to use.
3. I will get reference of that particular list from root sharepoint site.
4. With that reference, I will create a new list with exact same structure (columns including computed columns & data)

This gives me an advantage of not requiring changes in code if there are any changes to the list templates.

I have achieved this to somewhat extent ( though column formatting is not getting applied) using below code.

However, I was hoping that there would be an easier option to clone a list.

        await host.StartAsync();

        using var scope = host.Services.CreateScope();
        var pnPContextFactory = scope.ServiceProvider.GetRequiredService<IPnPContextFactory>();
        //var graphServiceClient = scope.ServiceProvider.GetRequiredService<GraphServiceClient>();

        using var defaultPnPContext = await pnPContextFactory.CreateAsync("Default");

        try
        {
            var siteContext = await defaultPnPContext.CloneAsync(
                new Uri($"https://{defaultPnPContext.Uri.DnsSafeHost}/sites/tcs-dev-641730-611821"));

            var rootList = await defaultPnPContext.Web.Lists.GetByTitleAsync("TRGList");


            var newList = await siteContext.Web.Lists.GetByTitleAsync("NewList") ??
                          await siteContext.Web.Lists.AddAsync("NewList", ListTemplateType.GenericList);

            var rootFields = rootList.Fields.ToList();
            var newListFields = newList.Fields.ToList();

            //add columns
            foreach (var rootField in rootFields)
            {
                if (newListFields.Any(x => x.Id == rootField.Id || x.Title == rootField.Title))
                    continue;

                if (rootField.FieldTypeKind == FieldType.Calculated)
                {
                    await newList.Fields.AddCalculatedAsync(rootField.Title, new FieldCalculatedOptions()
                    {
                        AddToDefaultView = true,
                        OutputType = rootField.OutputType,
                        Formula = rootField.Formula,
                        Group = rootField.Group,
                        ShowAsPercentage = rootField.ShowAsPercentage,
                        CustomFormatter = rootField.CustomFormatter
                    });
                    continue;
                }

                var addedField = await newList.Fields.AddFieldAsXmlAsync(rootField.SchemaXml, true);
                addedField.CustomFormatter = rootField.CustomFormatter;
                await addedField.UpdateAsync();
            }

            //refresh newListFields
            await newList.UpdateAsync();
            newListFields = newList.Fields.ToList();

            //add rows
            var rootItems = rootList.Items.ToList();
            var newListItems = newList.Items.ToList();

            foreach (var rootItem in rootItems)
            {
                var values = new Dictionary<string, object>();

                foreach (var value in rootItem.Values)
                {
                    if (value.Key is "Author" or "Editor" or "Attachments")
                        continue;

                    var rootFieldTitle = rootFields.First(x => x.InternalName == value.Key).Title;

                    var newListFieldInternalName = newListFields.First(x => x.Title == rootFieldTitle).InternalName;

                    values.Add(newListFieldInternalName, value.Value);
                }


                await newList.Items.AddAsync(values);
            }


            await newList.UpdateAsync();
            await siteContext.Web.UpdateAsync();
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex);
            throw;
        }
        finally
        {
            host.Dispose();
        }

[DmitriyVdE]

Ah yes, I see, so you go field-by-field and replicate the list.

You could also try making an XML export of the list (with linked CT and/or fields) using the provisioning engine, merge/extract only what you need in code, and have the provisioning engine handle the creation of the list. You'd have to manually add the list items to the data rows of the provisioning template if you want the data to be there as well. (as far as I know) Though I'm not sure if this would actually take more or less time/code. The handy thing about the provisioning engine is that you you can easily go from XML to a provisioning template object and back which allows you to play with both the object, as well as the base XML as you wish. And of course the fact that the provisioning engine does everything by itself, as long as the provided template is correct of course.