示例#1
0
        private void ParseDecorator(RawTemplate template, ref RawToken token, RawTokenEnumerator enumerator, ref FlatTokenParserState state, ref RawTokenDecorator decorator)
        {
            var next = enumerator.Next();

            if (string.IsNullOrWhiteSpace(next))
            {
                return;
            }

            switch (next)
            {
            case "}":
                token.Decorators.Add(decorator);
                template.Tokens.Add(token);
                token     = new RawToken();
                decorator = new RawTokenDecorator();
                state     = FlatTokenParserState.InPreamble;
                break;

            case ",":
                token.Decorators.Add(decorator);
                decorator = new RawTokenDecorator();
                break;

            case "(":
                state = FlatTokenParserState.InDecoratorArgument;
                break;

            default:
                decorator.AppendName(next);
                break;
            }
        }
示例#2
0
        public async Task <Template> AddTemplateAsync(RawTemplate rawTemplate)
        {
            var newTemplate = new Template(rawTemplate.TemplateName, rawTemplate.Subject, rawTemplate.Body);
            var result      = await _context.Templates.AddAsync(newTemplate);

            await _context.SaveChangesAsync();

            return(result.Entity);
        }
示例#3
0
 public async Task <IActionResult> AddNewTemplate(RawTemplate template)
 {
     return(Ok(await _emailTemplatesRepository.AddTemplateAsync(template)));
 }
示例#4
0
        private void ParseTokenName(RawTemplate template, ref RawToken token, RawTokenEnumerator enumerator, ref FlatTokenParserState state)
        {
            var next = enumerator.Next();
            var peek = enumerator.Peek();

            switch (next)
            {
            case "{":
                throw new ParsingException($"Unexpected character '{{' in token '{token.Name}'", enumerator);

            case "}":
                template.Tokens.Add(token);
                token = new RawToken();
                state = FlatTokenParserState.InPreamble;
                break;

            case "$":
                token.TerminateOnNewline = true;
                switch (peek)
                {
                case "?":
                case "*":
                case "}":
                case ":":
                    break;

                default:
                    throw new ParsingException($"Invalid character '{peek}' in token '{token.Name}'", enumerator);
                }
                break;

            case "?":
                token.Optional = true;
                switch (peek)
                {
                case "$":
                case "*":
                case "}":
                case ":":
                    break;

                default:
                    throw new ParsingException($"Invalid character '{peek}' in token '{token.Name}'", enumerator);
                }
                break;

            case "*":
                token.Repeating = true;
                token.Optional  = true;
                switch (peek)
                {
                case "$":
                case "?":
                case "}":
                case ":":
                    break;

                default:
                    throw new ParsingException($"Invalid character '{peek}' in token '{token.Name}'", enumerator);
                }
                break;

            case ":":
                state = FlatTokenParserState.InDecorator;
                break;

            default:
                if (token.Name == null)
                {
                    token.Name = string.Empty;
                }
                if (ValidTokenNameCharacters.Contains(next))
                {
                    token.Name += next;
                }
                else
                {
                    throw new ParsingException($"Invalid character '{next}' in token '{token.Name}'", enumerator);
                }
                break;
            }
        }
示例#5
0
        private void ParseFrontMatterOptionValue(RawTemplate template, RawTokenEnumerator enumerator, ref StringBuilder frontMatterName, ref StringBuilder frontMatterValue, ref FlatTokenParserState state)
        {
            var next = enumerator.Next();

            switch (next)
            {
            case "\n":
                var rawName = frontMatterName.ToString().Trim();
                var name    = frontMatterName.ToString().Trim().ToLowerInvariant();
                var value   = frontMatterValue.ToString().Trim().ToLowerInvariant();

                if (bool.TryParse(value, out var asBool))
                {
                    switch (name)
                    {
                    case "throwexceptiononmissingproperty":
                        template.Options.ThrowExceptionOnMissingProperty = asBool;
                        break;

                    case "trimleadingwhitespace":
                        template.Options.TrimLeadingWhitespaceInTokenPreamble = asBool;
                        break;

                    case "trimtrailingwhitespace":
                        template.Options.TrimTrailingWhiteSpace = asBool;
                        break;

                    case "outoforder":
                        template.Options.OutOfOrderTokens = asBool;
                        break;

                    case "casesensitive":
                        if (asBool)
                        {
                            template.Options.TokenStringComparison = StringComparison.InvariantCulture;
                        }
                        else
                        {
                            template.Options.TokenStringComparison = StringComparison.InvariantCultureIgnoreCase;
                        }
                        break;

                    default:
                        throw new ParsingException($"Unknown front matter option: {rawName}", enumerator);
                    }
                }
                else
                {
                    throw new ParsingException($"Unable to convert front matter option to boolean: {rawName}", enumerator);
                }

                frontMatterName.Clear();
                frontMatterValue.Clear();
                state = FlatTokenParserState.InFrontMatter;
                break;

            default:
                frontMatterValue.Append(next);
                break;
            }
        }
示例#6
0
        public RawTemplate Parse(string pattern, TokenizerOptions options)
        {
            var template = new RawTemplate();

            template.Options = options.Clone();

            var enumerator = new RawTokenEnumerator(pattern);

            if (enumerator.IsEmpty)
            {
                return(template);
            }

            var state            = FlatTokenParserState.AtStart;
            var token            = new RawToken();
            var decorator        = new RawTokenDecorator();
            var argument         = string.Empty;
            var frontMatterName  = new StringBuilder();
            var frontMatterValue = new StringBuilder();

            while (enumerator.IsEmpty == false)
            {
                switch (state)
                {
                case FlatTokenParserState.AtStart:
                    ParseStart(enumerator, ref state);
                    break;

                case FlatTokenParserState.InFrontMatter:
                    ParseFrontMatter(enumerator, ref frontMatterName, ref state);
                    break;

                case FlatTokenParserState.InFrontMatterComment:
                    ParseFrontMatterComment(enumerator, ref state);
                    break;

                case FlatTokenParserState.InFrontMatterOption:
                    ParseFrontMatterOption(enumerator, ref frontMatterName, ref state);
                    break;

                case FlatTokenParserState.InFrontMatterOptionValue:
                    ParseFrontMatterOptionValue(template, enumerator, ref frontMatterName, ref frontMatterValue, ref state);
                    break;

                case FlatTokenParserState.InPreamble:
                    ParsePreamble(ref token, enumerator, ref state);
                    break;

                case FlatTokenParserState.InTokenName:
                    ParseTokenName(template, ref token, enumerator, ref state);
                    break;

                case FlatTokenParserState.InDecorator:
                    ParseDecorator(template, ref token, enumerator, ref state, ref decorator);
                    break;

                case FlatTokenParserState.InDecoratorArgument:
                    ParseDecoratorArgument(enumerator, ref state, ref decorator, ref argument);
                    break;

                case FlatTokenParserState.InDecoratorArgumentSingleQuotes:
                    ParseDecoratorArgumentInSingleQuotes(enumerator, ref state, ref decorator, ref argument);
                    break;

                case FlatTokenParserState.InDecoratorArgumentDoubleQuotes:
                    ParseDecoratorArgumentInDoubleQuotes(enumerator, ref state, ref decorator, ref argument);
                    break;

                case FlatTokenParserState.InDecoratorArgumentRunOff:
                    ParseDecoratorArgumentRunOff(enumerator, ref state, ref decorator, ref argument);
                    break;


                default:
                    throw new TokenizerException($"Unknown FlatTokenParserState: {state}");
                }
            }

            // Append current token if it has contents
            // Note: allow empty token values, as these will serve to truncate the last
            // token in the template
            if (string.IsNullOrWhiteSpace(token.Preamble) == false)
            {
                template.Tokens.Add(token);
            }

            return(template);
        }
示例#7
0
        public Task <string[]> Test(string type)
        {
            //string type = "M01";
            int    ID   = 1000000085;
            string xhgg = "";
            string ccbh = "";
            string zzc  = "";

            int[]       Signer   = { 370340, 370540, 370440 };
            JDJLFM      jdjlfm   = new JDJLFM();      // 原始记录封面
            RawTemplate template = new RawTemplate(); // 原始记录模板
            Temperature wd       = new Temperature();

            jdjlfm.DWMC   = "山东省国土测绘院";
            jdjlfm.JDRQ   = DateTime.Now;
            template.MBMC = type;

            switch (type)
            {
            case "M01":
                ID   = 1000000087;   // 1000000085 1000000086 1000000087
                xhgg = "NET R9";
                ccbh = "5213K83647"; // 5146K79805 5146K79846 5213K83647
                zzc  = "美国天宝";

                jdjlfm.ID       = ID;
                template.QJMC   = "GPS接收机";
                template.QJMCBM = "1030";
                Signer[0]       = 370140;
                Signer[1]       = 370540;
                Signer[2]       = 370440;
                jdjlfm.JJWD     = wd.GetTemperature(ETemperature.OutRoom);// GPS    室外温度
                break;

            case "M02":
                ID   = 1000000063;
                xhgg = "TS60";
                ccbh = "883406";
                zzc  = "瑞士徕卡";

                jdjlfm.ID       = ID;
                template.QJMC   = "全站仪";
                template.QJMCBM = "1000";
                Signer[0]       = 370340;
                Signer[1]       = 370540;
                Signer[2]       = 370440;
                jdjlfm.QT05     = new Random().Next(990, 1030).ToString();   // 气压
                jdjlfm.JJWD     = wd.GetTemperature(ETemperature.InOutRoom); // 全站仪 室内外温度
                jdjlfm.CJJD     = "2";                                       // CJJD = 2 or 5
                jdjlfm.QT01     = "3";                                       // 补偿范围
                jdjlfm.QT02     = "1.5";                                     // BCJDA
                jdjlfm.QT03     = "1";                                       // BCJDB
                jdjlfm.QT04     = "2";                                       // 单双轴
                break;

            case "M03":     // 经纬仪
                ID   = 1000000078;
                xhgg = "";
                ccbh = "";
                zzc  = "";

                jdjlfm.ID       = ID;
                template.QJMC   = "经纬仪";
                template.QJMCBM = "1010";
                Signer[0]       = 370260;
                Signer[1]       = 370540;
                Signer[2]       = 370440;
                jdjlfm.JJWD     = wd.GetTemperature(ETemperature.InRoom);
                break;

            case "M04":     // 水准仪
                // DSZ05、DSZ1、DSZ3
                // DS05、DS1、DS3
                ID   = 1000000075;
                xhgg = "LS15";     // 数字水准仪
                ccbh = "703849";
                zzc  = "瑞士徕卡";

                // CJJD 1     2      3    4     5    6
                // CJJD DS05、DSZ05、DS1、DSZ1、DS3、DSZ3

                jdjlfm.CJJD = "1";     // 1 3 5 水准管水准仪 - 交叉误差
                jdjlfm.CJJD = "2";     // 2 4 6 自安平水准仪,电子水准仪2 4

                jdjlfm.ID       = ID;
                template.QJMC   = "水准仪";
                template.QJMCBM = "1020";
                Signer[0]       = 370260;
                Signer[1]       = 370540;
                Signer[2]       = 370440;
                jdjlfm.JJWD     = wd.GetTemperature(ETemperature.InRoom);
                break;

            case "M05":     // 手持激光测距仪
                ID   = 1000000111;
                xhgg = "DISTO D510";
                ccbh = "1073550958";
                zzc  = "瑞士徕卡";

                jdjlfm.ID       = ID;
                template.QJMC   = "手持激光测距仪";
                template.QJMCBM = "1040";
                Signer[0]       = 370440;
                Signer[1]       = 370540;
                Signer[2]       = 370440;
                jdjlfm.JJWD     = wd.GetTemperature(ETemperature.InRoom);
                break;

            case "M06":
                ID   = 1000000092;
                xhgg = "";
                ccbh = "";
                zzc  = "";

                jdjlfm.ID       = ID;
                template.QJMC   = "电子经纬仪";
                template.QJMCBM = "1100";
                Signer[0]       = 370260;
                Signer[1]       = 370540;
                Signer[2]       = 370440;
                jdjlfm.CJJD     = "2"; // CJJD = 2 or 5
                jdjlfm.QT01     = "3"; // 补偿范围
                jdjlfm.QT04     = "2"; // 单双轴
                jdjlfm.JJWD     = wd.GetTemperature(ETemperature.InRoom);
                break;

            default:
                break;
            }

            jdjlfm.QJMC = template.QJMC; // 可能和 template.QJMC 不一致

            jdjlfm.XHGG = xhgg;
            jdjlfm.CCBH = ccbh;
            jdjlfm.ZZC  = zzc;

            CertDto ipt = new CertDto();

            ipt.rawTemplate = template;
            ipt.jdjlfm      = jdjlfm;
            ipt.Signer      = Signer;

            return(_cert.MakeCert(ipt));
            //return _cert.MakeCert(jdjlfm, template, Signer);
        }