Ejemplo n.º 1
0
        public IEnumerable <DocumentRequisite> Read(ComponentsModel packageModel)
        {
            foreach (var model in packageModel.DocumentRequisites)
            {
                var entity = PackageHandlerUtils.CreateEntity <DocumentRequisite>(model);

                var fieldReq = model.Card.Requisites
                               .FirstOrDefault(r => r.Code == FieldReqName);
                if (fieldReq != null)
                {
                    entity.Field = fieldReq.DecodedText;
                }

                var sectionReq = model.Card.Requisites
                                 .FirstOrDefault(r => r.Code == SectionReqName);
                if (sectionReq != null)
                {
                    entity.Section = RequisiteHandlerUtils.GetRequisiteSection(sectionReq.ValueLocalizeID);
                }

                var typeReq = model.Card.Requisites
                              .FirstOrDefault(r => r.Code == TypeReqName);
                if (typeReq != null)
                {
                    entity.Type = RequisiteHandlerUtils.GetRequisiteType(typeReq.ValueLocalizeID);
                }

                var formatReq = model.Card.Requisites
                                .FirstOrDefault(r => r.Code == FormatReqName);
                if (formatReq != null)
                {
                    entity.Format = RequisiteHandlerUtils.GetRequisiteFormat(formatReq.ValueLocalizeID);
                }

                var lengthReq = model.Card.Requisites
                                .FirstOrDefault(r => r.Code == LengthReqName);
                if (!string.IsNullOrEmpty(lengthReq?.Value))
                {
                    entity.Length = int.Parse(lengthReq.Value);
                }

                var precissionReq = model.Card.Requisites
                                    .FirstOrDefault(r => r.Code == PrecissionReqName);
                if (!string.IsNullOrEmpty(precissionReq?.Value))
                {
                    entity.Precission = int.Parse(precissionReq.Value);
                }

                var referenceTypeReq = model.Card.Requisites
                                       .FirstOrDefault(r => r.Code == ReferenceTypeReqName);
                if (referenceTypeReq != null)
                {
                    entity.ReferenceType = referenceTypeReq.Value;
                }

                var referenceViewReq = model.Card.Requisites
                                       .FirstOrDefault(r => r.Code == ReferenceViewReqName);
                if (referenceViewReq != null)
                {
                    entity.ReferenceView = referenceViewReq.Value;
                }

                var pickValuesReq = model.Card.Requisites
                                    .FirstOrDefault(r => r.Code == PickValuesReqName);
                if (!string.IsNullOrEmpty(pickValuesReq?.DecodedText))
                {
                    var pickValues = pickValuesReq.DecodedText.Split(';');
                    foreach (var pickValue in pickValues)
                    {
                        var pickValueParts = pickValue.Split('=', '|');
                        var reqPickValue   = new RequisitePickValue
                        {
                            Id    = pickValueParts[0][0],
                            Value = pickValueParts[1]
                        };
                        entity.PickValues.Add(reqPickValue);
                    }
                }

                var isStoredReq = model.Card.Requisites
                                  .FirstOrDefault(r => r.Code == IsStoredReqName);
                if (isStoredReq != null)
                {
                    entity.IsStored = isStoredReq.ValueLocalizeID == Stored;
                }

                var isGeneratedReq = model.Card.Requisites
                                     .FirstOrDefault(r => r.Code == IsGeneratedReqName);
                if (isGeneratedReq != null)
                {
                    entity.IsGenerated = isGeneratedReq.ValueLocalizeID == Generated;
                }

                yield return(entity);
            }
        }
Ejemplo n.º 2
0
        public IEnumerable <ReferenceRequisite> Read(SqlConnection connection, Version platformVersion)
        {
            var components = new List <ReferenceRequisite>();
            var query      = this.GetReferenceRequisiteQuery(platformVersion);

            if (string.IsNullOrEmpty(query))
            {
                return(components);
            }

            var command = new SqlCommand(query, connection);

            using (var reader = command.ExecuteReader())
            {
                if (reader.HasRows)
                {
                    while (reader.Read())
                    {
                        var referenceRequisite = new ReferenceRequisite
                        {
                            Name  = reader["Name"] as string,
                            Title = reader["Title"] as string
                        };

                        if (reader["Section"] is string requisiteSectionValue &&
                            RequisiteSectionValues.ContainsKey(requisiteSectionValue))
                        {
                            referenceRequisite.Section = RequisiteSectionValues[requisiteSectionValue];
                        }

                        if (reader["Type"] is string requisiteTypeValue &&
                            RequisiteTypeValues.ContainsKey(requisiteTypeValue))
                        {
                            referenceRequisite.Type = RequisiteTypeValues[requisiteTypeValue];
                        }


                        if (reader["Format"] is string requisiteFormatValue &&
                            RequisiteFormatValues.ContainsKey(requisiteFormatValue))
                        {
                            referenceRequisite.Format = RequisiteFormatValues[requisiteFormatValue];
                        }

                        var lengthValue = reader["Length"];
                        if (lengthValue is int)
                        {
                            referenceRequisite.Length = (int)lengthValue;
                        }

                        var precissionValue = reader["Precission"];
                        if (precissionValue is int)
                        {
                            referenceRequisite.Precission = (int)precissionValue;
                        }

                        referenceRequisite.ReferenceType = reader["ReferenceType"] as string;
                        referenceRequisite.ReferenceView = reader["ReferenceView"] as string;

                        if (reader["PickValues"] is string pickValuesValue)
                        {
                            var pickValues = pickValuesValue.Split(';');
                            foreach (var pickValue in pickValues)
                            {
                                var pickValueParts = pickValue.Split('=', '|');
                                var reqPickValue   = new RequisitePickValue
                                {
                                    Id    = pickValueParts[0][0],
                                    Value = pickValueParts[1]
                                };
                                referenceRequisite.PickValues.Add(reqPickValue);
                            }
                        }

                        referenceRequisite.Field       = reader["Field"] as string;
                        referenceRequisite.IsStored    = IsStoredValue.Equals(reader["IsStored"] as string);
                        referenceRequisite.IsGenerated = IsGeneratedValue.Equals(reader["IsGenerated"] as string);

                        components.Add(referenceRequisite);
                    }
                }
            }
            return(components);
        }
Ejemplo n.º 3
0
        protected override IEnumerable <DialogRequisite> ReadComponents(ComponentModel model, string componentFolderPath)
        {
            var entity = PackageHandlerUtils.CreateEntity <DialogRequisite>(model);

            var sectionReq = model.Card.Requisites
                             .FirstOrDefault(r => r.Code == SectionReqName);

            if (sectionReq != null)
            {
                entity.Section = RequisiteHandlerUtils.GetRequisiteSection(sectionReq.ValueLocalizeID);
            }

            var typeReq = model.Card.Requisites
                          .FirstOrDefault(r => r.Code == TypeReqName);

            if (typeReq != null)
            {
                entity.Type = RequisiteHandlerUtils.GetRequisiteType(typeReq.ValueLocalizeID);
            }

            var formatReq = model.Card.Requisites
                            .FirstOrDefault(r => r.Code == FormatReqName);

            if (formatReq != null)
            {
                entity.Format = RequisiteHandlerUtils.GetRequisiteFormat(formatReq.ValueLocalizeID);
            }

            var lengthReq = model.Card.Requisites
                            .FirstOrDefault(r => r.Code == LengthReqName);

            if (!string.IsNullOrEmpty(lengthReq?.Value))
            {
                entity.Length = int.Parse(lengthReq.Value);
            }

            var precissionReq = model.Card.Requisites
                                .FirstOrDefault(r => r.Code == PrecissionReqName);

            if (!string.IsNullOrEmpty(precissionReq?.Value))
            {
                entity.Precission = int.Parse(precissionReq.Value);
            }

            var referenceTypeReq = model.Card.Requisites
                                   .FirstOrDefault(r => r.Code == ReferenceTypeReqName);

            if (referenceTypeReq != null)
            {
                entity.ReferenceType = referenceTypeReq.Value;
            }

            var referenceViewReq = model.Card.Requisites
                                   .FirstOrDefault(r => r.Code == ReferenceViewReqName);

            if (referenceViewReq != null)
            {
                entity.ReferenceView = referenceViewReq.Value;
            }

            var pickValuesReq = model.Card.Requisites
                                .FirstOrDefault(r => r.Code == PickValuesReqName);

            if (!string.IsNullOrEmpty(pickValuesReq?.Value))
            {
                var pickValues = pickValuesReq.Value.Split(';');
                foreach (var pickValue in pickValues)
                {
                    var pickValueParts = pickValue.Split('=', '|');
                    var reqPickValue   = new RequisitePickValue
                    {
                        Id    = pickValueParts[0][0],
                        Value = pickValueParts[1]
                    };
                    entity.PickValues.Add(reqPickValue);
                }
            }

            yield return(entity);
        }