Skip to content

Course material

This is the material for the Developing with DAM course. Please make sure you have attended the Using DAM course and/or read the DAM concept article and DAM developer overview article.

SDK

The NuGet package (Bizzkit.Sdk.Dam) is an automated swagger client that includes a factory client for easy authentication. See Swagger UI for reference.

API

The API consists of methods related to

  • Attributes
  • Files
  • Folders
  • Predefined settings
  • Task runner (background jobs)
  • Webhooks

and is more or less self-explanatory.

Reacting to changes

DAM has a basic event system to call an endpoint when a file is created, deleted, changed, etc. To enable events, you need to create a subscription to a specific event through the webhooks endpoint. See mere information here.

Examples

Based on the Getting-started console application here is a few examples in a helper class you can add to a project as DamHelper.cs.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
using Bizzkit.Sdk.Dam;

// WARNING: This is DEMO code and is not intended for production use. 
// Please review and modify before using in any production environment.
namespace Bizzkit.Academy
{
    public static class DamHelper
    {
        public static async Task<Guid> CreateFolder(Guid root, string name, string culture, DomainConfig config)
        {
            var client = await BizzkitHelper.GetDamClientFactory(config);
            var folder = await client.Folders_CreateAsync(culture, new CreateFolderModel { Name = name, ParentId = root });
            return folder;
        }

        public static async Task<CreatedSubscription> CreateWebHook(EventType eventType, string target, DomainConfig config)
        {
            var client = await BizzkitHelper.GetDamClientFactory(config);
            return await client.WebHooks_SubscribeAsync(eventType, new WebHookSubscriptionArguments
            {
                Target = target
            });
        }

        public static async Task DeleteFolder(string name, string culture, DomainConfig config)
        {
            var client = await BizzkitHelper.GetDamClientFactory(config);
            var response = await FolderExistsGetId(name, culture, config);
            if (!response.exists)
                throw new Exception(name + " does not exitst");
            await client.Folders_DeleteAsync(response.guid!.Value, culture);
        }

        public static async Task<PagedResultOfFiles> FilesInFolder(Guid folder, string culture, DomainConfig config)
        {
            var client = await BizzkitHelper.GetDamClientFactory(config);
            var files = await client.Folders_FilesAsync(folder, 1, int.MaxValue, SortOptions.AlphabeticalAscending, culture);
            return files;
        }

        public static async Task<bool> FolderExists(string name, string culture, DomainConfig config)
        {
            var client = await BizzkitHelper.GetDamClientFactory(config);
            var folder = await client.Folders_ListByNameAsync(name, null, culture);
            return folder.Count() > 0;
        }

        public static async Task<(bool exists, Guid? guid)> FolderExistsGetId(string name, string culture, DomainConfig config)
        {
            var client = await BizzkitHelper.GetDamClientFactory(config);
            var folder = await client.Folders_ListByNameAsync(name, null, culture);
            if (folder.Count() > 0)
                return (true, folder.First().Id);
            else
                return (false, null);
        }

        public static async Task<PagedResultOfFolders> FoldersUnderRoot(Guid root, string culture, DomainConfig config)
        {
            var client = await BizzkitHelper.GetDamClientFactory(config);
            var folders = await client.Folders_ChildrenAsync(root, 1, int.MaxValue, culture);
            return folders;

        }

        public static async Task<IEnumerable<CachedFileDetailsResult>> GetFile100(Guid file, string culture, DomainConfig config)
        {
            var client = await BizzkitHelper.GetDamClientFactory(config);
            var request = new List<CachedFileInfoParameter>(){
                new CachedFileInfoParameter (){
                    FileId = file,
                    Height = 100,
                    ImageType = CachedFileInfoParameterImageType.Png,
                    Transformation = CachedFileInfoParameterTransformation.Resize
                }
            };
            var response = await client.Files_CachedDetailsAsync(culture, request);
            return response;
        }

        public static async Task<IEnumerable<CachedFileDetailsResult>> GetFilePredfinedSetting(Guid file, string culture, string predefinedSettingName, DomainConfig config)
        {
            var client = await BizzkitHelper.GetDamClientFactory(config);
            var preDefinedSetting = await client.PredefinedSettings_SingleByNameAsync(predefinedSettingName);
            var request = new List<CachedFileInfoParameter>(){
                new CachedFileInfoParameter (){
                    FileId = file,
                    PredefinedSettingId = preDefinedSetting.Id,
                    Transformation = CachedFileInfoParameterTransformation.PredefinedSetting
                }
            };
            var response = await client.Files_CachedDetailsAsync(culture, request);
            return response;
        }

        public static async Task<IEnumerable<CachedFileDetailsResult>> GetFirstFileWithCropping(string culture, DomainConfig config)
        {
            var client = await BizzkitHelper.GetDamClientFactory(config);
            var allImages = await client.Files_KnownOriginalAndPredefinedSettingCachedEntriesAsync(1, int.MaxValue, culture);
            var file = allImages.PageItems.ToList().FirstOrDefault(f => f.CroppingId != null);
            var request = new List<CachedFileInfoParameter>(){
                new CachedFileInfoParameter (){
                    FileId = file!.FileId,
                    CroppingId = file.CroppingId
                }
            };
            var response = await client.Files_CachedDetailsAsync(culture, request);
            return response;
        }

        public static async Task<Guid> GetRootFolder(string culture, DomainConfig config)
        {
            var client = await BizzkitHelper.GetDamClientFactory(config);
            var root = await client.Folders_RootAsync(culture);
            return root;
        }
        public static async Task<ImportFileResult> UploadFile(Guid folder, string filePath, string culture, DomainConfig config)
        {
            var client = await BizzkitHelper.GetDamClientFactory(config);
            ImportFileFromByteDataParameters request = new ImportFileFromByteDataParameters();
            request.FileData = await System.IO.File.ReadAllBytesAsync(filePath);
            request.FileName = System.IO.Path.GetFileName(filePath);
            request.Description = System.IO.Path.GetFileName(filePath);
            request.ParentFolderId = folder;
            var newFile = await client.Files_ImportFromByteDataAsync(culture, request);
            return newFile;
        }
    }
}