Example #1
0
        /// <summary>
        /// 查找架构
        /// </summary>
        /// <param name="schemaId">架构标识</param>
        public SchemaInfo FindSchema(string schemaId)
        {
            var result = Schemas.FirstOrDefault(x => x.SchemaId == schemaId);

            if (result == null)
            {
                throw new ArgumentException($"{schemaId} Schema Not Found.");
            }

            return(result);
        }
Example #2
0
        private void NoSchemaIsActive()
        {
            var oldActive = Schemas.FirstOrDefault(sch => sch.IsActive);

            if (oldActive != null)
            {
                ((PowerSchema)oldActive).IsActive = false;

                CurrentSchema = null;
                RaisePropertyChangedEvent(nameof(CurrentSchema));
            }
        }
Example #3
0
        private void SetNewCurrSchema(IPowerSchema newActiveSchema)
        {
            var oldActiveSchema = Schemas.FirstOrDefault(sch => sch.IsActive);

            ((PowerSchema)newActiveSchema).IsActive = true;
            CurrentSchema = newActiveSchema;
            RaisePropertyChangedEvent(nameof(CurrentSchema));

            //can cause change change of curr power schema: http://stackoverflow.com/questions/42703092/remove-selection-when-selected-item-gets-deleted-from-listbox
            if (oldActiveSchema != null)
            {
                ((PowerSchema)oldActiveSchema).IsActive = false;
            }
        }
Example #4
0
        public void UpdateSchemas()
        {
            var currSchemaGuid = powerWraper.GetActiveGuid();
            var newSchemas     = powerWraper.GetCurrentSchemas();

            //Add and update new / changed schemas
            foreach (var newSchema in newSchemas)
            {
                var originalSchema = Schemas.FirstOrDefault(sch => sch.Guid == newSchema.Guid);
                if (originalSchema == null)
                {
                    InsertNewSchema(newSchemas, newSchema); originalSchema = newSchema;
                }

                if (newSchema.Guid == currSchemaGuid && originalSchema?.IsActive != true)
                {
                    SetNewCurrSchema(originalSchema);
                }

                if (originalSchema?.Name != newSchema.Name)
                {
                    ((PowerSchema)originalSchema).Name = newSchema.Name;
                }
            }

            if (!Schemas.Any(sch => currSchemaGuid == sch.Guid))
            {
                NoSchemaIsActive();
            }

            //remove old schemas
            var schemasToBeRemoved = new List <IPowerSchema>();

            foreach (var oldSchema in Schemas)
            {
                if (newSchemas.FirstOrDefault(sch => sch.Guid == oldSchema.Guid) == null)
                {
                    schemasToBeRemoved.Add(oldSchema);
                }
            }
            schemasToBeRemoved.ForEach(sch => Schemas.Remove(sch));
        }
Example #5
0
        public void UpdateSchemas()
        {
            var currSchemaGuid = powerWraper.GetActiveGuid();
            var newSchemas     = powerWraper.GetCurrentSchemas();

            //Add and update new / changed schemas
            foreach (var newSchema in newSchemas)
            {
                var originalSchema = Schemas.FirstOrDefault(sch => sch.Guid == newSchema.Guid);
                if (originalSchema == null)
                {
                    insertNewSchema(newSchemas, newSchema);
                }

                if (newSchema.Guid == currSchemaGuid)
                {
                    handleCurrentSchema(newSchema, originalSchema);
                }

                if (newSchema.Guid != currSchemaGuid && originalSchema?.IsActive == true)
                {
                    updateSchema(originalSchema, false);
                }

                if (originalSchema != null && originalSchema.Name != newSchema.Name)
                {
                    ((PowerSchema)originalSchema).Name = newSchema.Name;
                }
            }

            //remove old schemas
            foreach (var oldSchema in Schemas)
            {
                if (newSchemas.FirstOrDefault(sch => sch.Guid == oldSchema.Guid) == null)
                {
                    Schemas.Remove(oldSchema);
                }
            }
        }
Example #6
0
        protected virtual T ReadArgument <T>(string name)
        {
            var schema = Schemas.FirstOrDefault(s => s.Name.Equals(name) || s.ShortName.Equals(name));

            if (schema == null)
            {
                throw new ArgumentException($"Argument {{f:Yellow}}{name}{{f:d}} is not defined.");
            }

            var regex = new Regex($"^((-{schema.ShortName})|(--{schema.Name}))([:=].*)?$");

            var result = Arguments.FirstOrDefault(a => regex.IsMatch(a));

            if (!string.IsNullOrWhiteSpace(result))
            {
                result = Regex.Replace(result.Trim(), $"^((-{schema.ShortName})|(--{schema.Name}))[:=]?", "");
                if (!string.IsNullOrWhiteSpace(result))
                {
                    return((T)Convert.ChangeType(result.Trim(), typeof(T)));
                }
                if (schema.IsRequired && !schema.IsUninary)
                {
                    throw new ArgumentException($"Argument {{f:Yellow}}{schema.Name}{{f:d}} should have a value.");
                }
                if (schema.IsUninary)
                {
                    return((T)Convert.ChangeType("true", typeof(T)));
                }
                return(default(T));
            }

            if (schema.IsRequired)
            {
                throw new ArgumentException($"Missing argument {{f:Yellow}}{name}{{f:d}}.");
            }

            return(default(T));
        }
Example #7
0
 public PgSchema GetSchema(string name)
 {
     return(name != null
         ? Schemas.FirstOrDefault(schema => schema.Name.Equals(name))
         : DefaultSchema);
 }
 public SCIMSchema GetSchema(string id)
 {
     return(Schemas.FirstOrDefault(s => s.Id == id));
 }
 public SCIMSchema GetSchema(SCIMSchemaAttribute attribute)
 {
     return(Schemas.FirstOrDefault(s => s.HasAttribute(attribute)));
 }
 public SCIMSchema GetRootSchema()
 {
     return(Schemas.FirstOrDefault(s => s.IsRootSchema));
 }