Beispiel #1
0
        public static async Task DeleteRecursiveAsync(BusinessModuleFactory businessModuleFactory, IDataFactory dataFactory, ICacheRepository cacheRepository, ItemDataModel itemDataModel)
        {
            var siteId = itemDataModel.SiteId;

            if (string.IsNullOrEmpty(siteId))
            {
                siteId = itemDataModel.Id;
            }
            var items =
                await
                dataFactory.ItemRepository.GetItemsAsync(siteId, new ItemFilters { ParentId = itemDataModel.Id });

            if (items != null)
            {
                foreach (var item in items)
                {
                    {
                        var module = businessModuleFactory.GetModuleCreate(item.Module);
                        if (module != null)
                        {
                            await module.DeleteAsync(dataFactory, cacheRepository, item);
                        }
                    }
                }
            }

            await dataFactory.DeleteAsync(itemDataModel);
        }
        protected override async Task ActionAsync()
        {
            await UserSecurity.CheckAdministratorAsync(_userService, Input.UserId, Input.Data.Site.SiteId);

            await _dataFactory.DeleteAsync <DataModelBase>(Input.Data.Site.SiteId, Input.Data.ModuleId);

            await _dataFactory.SaveChangeAsync();

            await _cacheProvider.UpdateCacheAsync(Input.Data.Site.SiteId);

            Result.Data = await _moduleManager.GetMasterAsync(Input.Data.Site);
        }
Beispiel #3
0
        protected async Task ActionAsync()
        {
            await UserSecurity.CheckIsSuperAdministratorAsync(_userService, Input.UserId);

            var item = await _dataFactory.ItemRepository.GetItemAsync(Input.Data.SiteId, Input.Data.ModuleId);

            await _dataFactory.DeleteAsync <DataModelBase>(item);

            await _dataFactory.SaveChangeAsync();

            await _cacheProvider.UpdateCacheAsync(item.SiteId);
        }
Beispiel #4
0
        public async Task DeleteAsync(IDataFactory dataFactory, ICacheRepository cacheRepository, ItemDataModel itemDataModel)
        {
            var files =
                await
                dataFactory.ItemRepository.DownloadsAsync(itemDataModel.SiteId,
                                                          itemDataModel.Id);

            foreach (var fileDataModel in files)
            {
                await dataFactory.DeleteFileAsync(fileDataModel.Id);
            }

            await dataFactory.DeleteAsync(itemDataModel);
        }
        protected override async Task ActionAsync()
        {
            if (string.IsNullOrEmpty(Input.PropertyName))
            {
                var itemDataModel = await _dataFactory.ItemRepository.GetItemAsync(Input.SiteId, Input.Id);

                await _dataFactory.DeleteAsync(itemDataModel);
            }
            else
            {
                var itemDataModels =
                    await
                    _dataFactory.ItemRepository.GetItemsAsync(Input.SiteId,
                                                              new ItemFilters { ParentId = Input.Id, Module = "Image", PropertyName = Input.PropertyName });

                foreach (var dataModel in itemDataModels)
                {
                    await _dataFactory.DeleteAsync(dataModel);
                }
            }

            await _dataFactory.SaveChangeAsync();
        }