Exemple #1
0
 public bool Supports(ExportFeatures feature)
 {
     return(!IsPreview && Request.Provider.Metadata.ExportFeatures.HasFlag(feature));
 }
Exemple #2
0
        public virtual async Task <ExportProfile> InsertExportProfileAsync(
            string providerSystemName,
            string name,
            string fileExtension,
            ExportFeatures features,
            bool isSystemProfile     = false,
            string profileSystemName = null,
            int cloneFromProfileId   = 0)
        {
            Guard.NotEmpty(providerSystemName, nameof(providerSystemName));

            if (name.IsEmpty())
            {
                name = providerSystemName;
            }

            if (!isSystemProfile)
            {
                var profileCount = await _db.ExportProfiles.CountAsync(x => x.ProviderSystemName == providerSystemName);

                name = $"{T("Common.My").Value} {name} {profileCount + 1}";
            }

            TaskDescriptor task         = null;
            ExportProfile  cloneProfile = null;
            ExportProfile  profile      = null;

            if (cloneFromProfileId != 0)
            {
                cloneProfile = await _db.ExportProfiles
                               .Include(x => x.Task)
                               .Include(x => x.Deployments)
                               .FindByIdAsync(cloneFromProfileId);
            }

            if (cloneProfile == null)
            {
                task = new TaskDescriptor
                {
                    CronExpression = "0 */6 * * *",     // Every six hours.
                    Type           = nameof(DataExportTask),
                    Enabled        = false,
                    StopOnError    = false,
                    IsHidden       = true
                };
            }
            else
            {
                task = cloneProfile.Task.Clone();
            }

            task.Name = name + " Task";

            _db.TaskDescriptors.Add(task);

            // Get the task ID.
            await _db.SaveChangesAsync();

            if (cloneProfile == null)
            {
                profile = new ExportProfile
                {
                    FileNamePattern = _defaultFileNamePattern
                };

                if (isSystemProfile)
                {
                    profile.Enabled          = true;
                    profile.PerStore         = false;
                    profile.CreateZipArchive = false;
                    profile.Cleanup          = false;
                }
                else
                {
                    // What we do here is to preset typical settings for feed creation
                    // but on the other hand they may be untypical for generic data export\exchange.
                    var projection = new ExportProjection
                    {
                        RemoveCriticalCharacters = true,
                        CriticalCharacters       = "¼,½,¾",
                        PriceType         = PriceDisplayType.PreSelectedPrice,
                        NoGroupedProducts = features.HasFlag(ExportFeatures.CanOmitGroupedProducts),
                        OnlyIndividuallyVisibleAssociated = true,
                        DescriptionMerging = ExportDescriptionMerging.Description
                    };

                    var filter = new ExportFilter
                    {
                        IsPublished        = true,
                        ShoppingCartTypeId = (int)ShoppingCartType.ShoppingCart
                    };

                    using var writer1 = new StringWriter();
                    new XmlSerializer(typeof(ExportProjection)).Serialize(writer1, projection);
                    profile.Projection = writer1.ToString();

                    using var writer2 = new StringWriter();
                    new XmlSerializer(typeof(ExportFilter)).Serialize(writer2, projection);
                    profile.Filtering = writer2.ToString();
                }
            }
            else
            {
                profile = cloneProfile.Clone();
            }

            profile.IsSystemProfile    = isSystemProfile;
            profile.Name               = name;
            profile.ProviderSystemName = providerSystemName;
            profile.TaskId             = task.Id;

            var cleanedSystemName = providerSystemName
                                    .Replace("Exports.", string.Empty)
                                    .Replace("Feeds.", string.Empty)
                                    .Replace("/", string.Empty)
                                    .Replace("-", string.Empty);

            var directoryName = SeoHelper.BuildSlug(cleanedSystemName, true, false, false)
                                .ToValidPath()
                                .Truncate(_dataExchangeSettings.MaxFileNameLength);

            // TODO: (mg) (core) find out how to correctly build new app relative paths for ExportProfile.FolderName like x '~/App_Data/Tenants/Default/ExportProfiles/bmecatproductxml-1-2'
            // ExportProfile.FolderName must fulfil PathHelper.IsSafeAppRootPath! See also below.
            var tenantRoot       = DataSettings.Instance.TenantRoot;
            var profileDirectory = tenantRoot.GetDirectory("ExportProfiles");

            // TODO: (mg) (core) TenantRoot is rooted to the tenant dir and DOES NOT CONTAIN "App_Data/Tenants/{TenantName}" anymore.
            // The result will be "ExportProfiles/{UniqueDirName}, which conflicts with how we saved the path in the past ("~/App_Data/..."). You must
            // "upgrade" legacy pathes to new root whenever an entity is loaded and processed.
            profile.FolderName = tenantRoot.PathCombine(profileDirectory.SubPath, tenantRoot.CreateUniqueDirectoryName(profileDirectory.SubPath, directoryName));

            profile.SystemName = profileSystemName.IsEmpty() && isSystemProfile
                ? cleanedSystemName
                : profileSystemName;

            _db.ExportProfiles.Add(profile);

            // Get the export profile ID.
            await _db.SaveChangesAsync();

            task.Alias = profile.Id.ToString();

            if (fileExtension.HasValue() && !isSystemProfile)
            {
                if (cloneProfile == null)
                {
                    if (features.HasFlag(ExportFeatures.CreatesInitialPublicDeployment))
                    {
                        var subFolder = tenantRoot.CreateUniqueDirectoryName(DataExporter.PublicFolder, directoryName);

                        profile.Deployments.Add(new ExportDeployment
                        {
                            ProfileId      = profile.Id,
                            Enabled        = true,
                            DeploymentType = ExportDeploymentType.PublicFolder,
                            Name           = profile.Name,
                            SubFolder      = subFolder
                        });
                    }
                }
                else
                {
                    cloneProfile.Deployments.Each(x => profile.Deployments.Add(x.Clone()));
                }
            }

            // Finally update task and export profile.
            await _db.SaveChangesAsync();

            return(profile);
        }
Exemple #3
0
        public virtual ExportProfile InsertExportProfile(
            string providerSystemName,
            string name,
            string fileExtension,
            ExportFeatures features,
            bool isSystemProfile     = false,
            string profileSystemName = null,
            int cloneFromProfileId   = 0)
        {
            Guard.ArgumentNotEmpty(() => providerSystemName);

            var profileCount = _exportProfileRepository.Table.Count(x => x.ProviderSystemName == providerSystemName);

            if (name.IsEmpty())
            {
                name = providerSystemName;
            }

            if (!isSystemProfile)
            {
                name = string.Concat(_localizationService.GetResource("Common.My"), " ", name);
            }

            name = string.Concat(name, " ", profileCount + 1);

            var cloneProfile = GetExportProfileById(cloneFromProfileId);

            ScheduleTask  task    = null;
            ExportProfile profile = null;

            if (cloneProfile == null)
            {
                task = new ScheduleTask
                {
                    CronExpression = "0 */6 * * *",                         // every six hours
                    Type           = typeof(DataExportTask).AssemblyQualifiedNameWithoutVersion(),
                    Enabled        = false,
                    StopOnError    = false,
                    IsHidden       = true
                };
            }
            else
            {
                task            = cloneProfile.ScheduleTask.Clone();
                task.LastEndUtc = task.LastStartUtc = task.LastSuccessUtc = null;
            }

            task.Name = string.Concat(name, " Task");

            _scheduleTaskService.InsertTask(task);

            if (cloneProfile == null)
            {
                profile = new ExportProfile
                {
                    FileNamePattern = _defaultFileNamePattern
                };

                if (isSystemProfile)
                {
                    profile.Enabled          = true;
                    profile.PerStore         = false;
                    profile.CreateZipArchive = false;
                    profile.Cleanup          = false;
                }
                else
                {
                    // what we do here is to preset typical settings for feed creation
                    // but on the other hand they may be untypical for generic data export\exchange
                    var projection = new ExportProjection
                    {
                        RemoveCriticalCharacters = true,
                        CriticalCharacters       = "¼,½,¾",
                        PriceType          = PriceDisplayType.PreSelectedPrice,
                        NoGroupedProducts  = (features.HasFlag(ExportFeatures.CanOmitGroupedProducts) ? true : false),
                        DescriptionMerging = ExportDescriptionMerging.Description
                    };

                    var filter = new ExportFilter
                    {
                        IsPublished = true
                    };

                    profile.Projection = XmlHelper.Serialize <ExportProjection>(projection);
                    profile.Filtering  = XmlHelper.Serialize <ExportFilter>(filter);
                }
            }
            else
            {
                profile = cloneProfile.Clone();
            }

            profile.IsSystemProfile    = isSystemProfile;
            profile.Name               = name;
            profile.ProviderSystemName = providerSystemName;
            profile.SchedulingTaskId   = task.Id;

            var cleanedSystemName = providerSystemName
                                    .Replace("Exports.", "")
                                    .Replace("Feeds.", "")
                                    .Replace("/", "")
                                    .Replace("-", "");

            var folderName = SeoHelper.GetSeName(cleanedSystemName, true, false)
                             .ToValidPath()
                             .Truncate(_dataExchangeSettings.MaxFileNameLength);

            profile.FolderName = "~/App_Data/ExportProfiles/" + FileSystemHelper.CreateNonExistingDirectoryName(CommonHelper.MapPath("~/App_Data/ExportProfiles"), folderName);

            if (profileSystemName.IsEmpty() && isSystemProfile)
            {
                profile.SystemName = cleanedSystemName;
            }
            else
            {
                profile.SystemName = profileSystemName;
            }

            _exportProfileRepository.Insert(profile);


            task.Alias = profile.Id.ToString();
            _scheduleTaskService.UpdateTask(task);

            if (fileExtension.HasValue() && !isSystemProfile)
            {
                if (cloneProfile == null)
                {
                    if (features.HasFlag(ExportFeatures.CreatesInitialPublicDeployment))
                    {
                        var subFolder = FileSystemHelper.CreateNonExistingDirectoryName(CommonHelper.MapPath("~/" + DataExporter.PublicFolder), folderName);

                        profile.Deployments.Add(new ExportDeployment
                        {
                            ProfileId      = profile.Id,
                            Enabled        = true,
                            DeploymentType = ExportDeploymentType.PublicFolder,
                            Name           = profile.Name,
                            SubFolder      = subFolder
                        });

                        UpdateExportProfile(profile);
                    }
                }
                else
                {
                    foreach (var deployment in cloneProfile.Deployments)
                    {
                        profile.Deployments.Add(deployment.Clone());
                    }

                    UpdateExportProfile(profile);
                }
            }

            _eventPublisher.EntityInserted(profile);

            return(profile);
        }
        public virtual ExportProfile InsertExportProfile(
			string providerSystemName,
			string name,
			string fileExtension,
			ExportFeatures features,
			bool isSystemProfile = false,
			string profileSystemName = null,
			int cloneFromProfileId = 0)
        {
            Guard.ArgumentNotEmpty(() => providerSystemName);

            var profileCount = _exportProfileRepository.Table.Count(x => x.ProviderSystemName == providerSystemName);

            if (name.IsEmpty())
                name = providerSystemName;

            if (!isSystemProfile)
                name = string.Concat(_localizationService.GetResource("Common.My"), " ", name);

            name = string.Concat(name, " ", profileCount + 1);

            var cloneProfile = GetExportProfileById(cloneFromProfileId);

            ScheduleTask task = null;
            ExportProfile profile = null;

            if (cloneProfile == null)
            {
                task = new ScheduleTask
                {
                    CronExpression = "0 */6 * * *",     // every six hours
                    Type = typeof(DataExportTask).AssemblyQualifiedNameWithoutVersion(),
                    Enabled = false,
                    StopOnError = false,
                    IsHidden = true
                };
            }
            else
            {
                task = cloneProfile.ScheduleTask.Clone();
                task.LastEndUtc = task.LastStartUtc = task.LastSuccessUtc = null;
            }

            task.Name = string.Concat(name, " Task");

            _scheduleTaskService.InsertTask(task);

            if (cloneProfile == null)
            {
                profile = new ExportProfile
                {
                    FileNamePattern = _defaultFileNamePattern
                };

                if (isSystemProfile)
                {
                    profile.Enabled = true;
                    profile.PerStore = false;
                    profile.CreateZipArchive = false;
                    profile.Cleanup = false;
                }
                else
                {
                    // what we do here is to preset typical settings for feed creation
                    // but on the other hand they may be untypical for generic data export\exchange
                    var projection = new ExportProjection
                    {
                        RemoveCriticalCharacters = true,
                        CriticalCharacters = "¼,½,¾",
                        PriceType = PriceDisplayType.PreSelectedPrice,
                        NoGroupedProducts = (features.HasFlag(ExportFeatures.CanOmitGroupedProducts) ? true : false),
                        DescriptionMerging = ExportDescriptionMerging.Description
                    };

                    var filter = new ExportFilter
                    {
                        IsPublished = true
                    };

                    profile.Projection = XmlHelper.Serialize<ExportProjection>(projection);
                    profile.Filtering = XmlHelper.Serialize<ExportFilter>(filter);
                }
            }
            else
            {
                profile = cloneProfile.Clone();
            }

            profile.IsSystemProfile = isSystemProfile;
            profile.Name = name;
            profile.ProviderSystemName = providerSystemName;
            profile.SchedulingTaskId = task.Id;

            var cleanedSystemName = providerSystemName
                .Replace("Exports.", "")
                .Replace("Feeds.", "")
                .Replace("/", "")
                .Replace("-", "");

            var folderName = SeoHelper.GetSeName(cleanedSystemName, true, false)
                .ToValidPath()
                .Truncate(_dataExchangeSettings.MaxFileNameLength);

            profile.FolderName = "~/App_Data/ExportProfiles/" + FileSystemHelper.CreateNonExistingDirectoryName(CommonHelper.MapPath("~/App_Data/ExportProfiles"), folderName);

            if (profileSystemName.IsEmpty() && isSystemProfile)
                profile.SystemName = cleanedSystemName;
            else
                profile.SystemName = profileSystemName;

            _exportProfileRepository.Insert(profile);

            task.Alias = profile.Id.ToString();
            _scheduleTaskService.UpdateTask(task);

            if (fileExtension.HasValue() && !isSystemProfile)
            {
                if (cloneProfile == null)
                {
                    if (features.HasFlag(ExportFeatures.CreatesInitialPublicDeployment))
                    {
                        var subFolder = FileSystemHelper.CreateNonExistingDirectoryName(CommonHelper.MapPath("~/" + DataExporter.PublicFolder), folderName);

                        profile.Deployments.Add(new ExportDeployment
                        {
                            ProfileId = profile.Id,
                            Enabled = true,
                            DeploymentType = ExportDeploymentType.PublicFolder,
                            Name = profile.Name,
                            SubFolder = subFolder
                        });

                        UpdateExportProfile(profile);
                    }
                }
                else
                {
                    foreach (var deployment in cloneProfile.Deployments)
                    {
                        profile.Deployments.Add(deployment.Clone());
                    }

                    UpdateExportProfile(profile);
                }
            }

            _eventPublisher.EntityInserted(profile);

            return profile;
        }