Esempio n. 1
0
        public mFactor GetFactor(AppDbContext ltctx, int sequence_no)
        {
            var _analysis = ltctx.tb_lion_analysis
                            .Where(x => x.SequenceNo < sequence_no)
                            .OrderByDescending(x => x.SequenceNo)
                            .Take(1)
                            .SingleOrDefault();

            var _factor = ltctx.tb_lion_factor
                          .Where(x => x.SequenceNo <= sequence_no)
                          .OrderByDescending(x => x.SequenceNo)
                          .Take(1)
                          .SingleOrDefault();

            if (_factor != null)
            {
                if (_factor.SequenceNo != sequence_no)
                {
                    var _new_factor = new mFactor()
                    {
                        SequenceNo = sequence_no,

                        LNoSampling    = _factor.LNoSampling,                               // 좌측 조합을 위한 번호 모집단 (보통 27개 이하)
                        LNoCombination = 0,                                                 // 좌측 완전 조합 갯수
                        LNoExtraction  = 0,                                                 // 각 회차 별 필터링을 거쳐 추출 된 게임 갯수

                        RNoSampling    = _factor.RNoSampling,                               // 우측 조합을 위한 번호 모집단 (보통 27개 이하)
                        RNoCombination = 0,                                                 // 우측 완전 조합 갯수
                        RNoExtraction  = 0,                                                 // 각 회차 별 필터링을 거쳐 추출 된 게임 갯수

                        MinOddEven = _factor.MinOddEven,                                    // 홀수 최소 발생 갯수
                        MaxOddEven = _factor.MaxOddEven,                                    // 홀수 최대 발생 갯수

                        MinHighLow = _factor.MinHighLow,                                    // 고저 최소 발생 갯수
                        MaxHighLow = _factor.MaxHighLow,                                    // 고저 최대 발생 갯수

                        OddSelection  = _analysis.SumOdd > _analysis.SumEven,               // 홀수 짝수 선택(홀짝 계산 값이 홀수 값 이면 제외 함)
                        HighSelection = _analysis.SumHigh > _analysis.SumLow,               // 고저 번호 선택(고저 계산 값이 낮은 값 이면 제외 함)

                        MaxSumFrequence = _factor.MaxSumFrequence,                          // 합계 발생 빈도(과거 당첨번호 합계가 1번 이하 이면 제외 함)
                        MaxGroupBalance = _factor.MaxGroupBalance,                          // 최대 집단 빈도(번호가 없는 집단이 3개 이상 이면 제외 함)

                        MaxLastNumber   = _factor.MaxLastNumber,                            // 끝수 동일 갯수(끝자리 숫자가 3개 이상 동일 하면 제외 함)
                        MaxSeriesNumber = _factor.MaxSeriesNumber,                          // 일련 번호 갯수(3자리 이상 번호가 연번이면 제외 함)

                        MaxSameDigits  = _factor.MaxSameDigits,                             // 과거 당첨 번호 중 같은 번호가 출현한 갯수
                        MaxSameJackpot = _factor.MaxSameJackpot,                            // 같은 번호가 3회 이상 발생 한 흔적이 거의 없음

                        NoJackpot1 = 0,
                        NoJackpot2 = 0,
                        NoJackpot3 = 0,
                        NoJackpot4 = 0,
                        NoJackpot5 = 0,

                        WinningAmount1 = 0m,
                        WinningAmount2 = 0m,
                        WinningAmount3 = 0m,
                        WinningAmount4 = 0m,
                        WinningAmount5 = 0m
                    };

                    ltctx.tb_lion_factor.Add(_new_factor);
                    _factor = _new_factor;
                }
                else
                {
                    _factor.OddSelection  = _analysis.SumOdd > _analysis.SumEven;
                    _factor.HighSelection = _analysis.SumHigh > _analysis.SumLow;
                }
            }
            else
            {
                var _new_factor = new mFactor()
                {
                    SequenceNo = sequence_no,

                    LNoSampling    = 30,                                                // 좌측 조합을 위한 번호 모집단 (보통 27개 이하)
                    LNoCombination = 0,                                                 // 좌측 완전 조합 갯수
                    LNoExtraction  = 0,                                                 // 각 회차 별 필터링을 거쳐 추출 된 게임 갯수

                    RNoSampling    = 0,                                                 // 우측 조합을 위한 번호 모집단 (보통 27개 이하)
                    RNoCombination = 0,                                                 // 우측 완전 조합 갯수
                    RNoExtraction  = 0,                                                 // 각 회차 별 필터링을 거쳐 추출 된 게임 갯수

                    MinOddEven = 1,                                                     // 홀수 최소 발생 갯수
                    MaxOddEven = 5,                                                     // 홀수 최대 발생 갯수

                    MinHighLow = 1,                                                     // 고저 최소 발생 갯수
                    MaxHighLow = 5,                                                     // 고저 최대 발생 갯수

                    OddSelection  = _analysis.SumOdd > _analysis.SumEven,               // 홀수 짝수 선택(홀짝 계산 값이 홀수 값 이면 제외 함)
                    HighSelection = _analysis.SumHigh > _analysis.SumLow,               // 고저 번호 선택(고저 계산 값이 낮은 값 이면 제외 함)

                    MaxSumFrequence = 2,                                                // 합계 발생 빈도(과거 당첨번호 합계가 1번 이하 이면 제외 함)
                    MaxGroupBalance = 3,                                                // 최대 집단 빈도(번호가 없는 집단이 3개 이상 이면 제외 함)

                    MaxLastNumber   = 3,                                                // 끝수 동일 갯수(끝자리 숫자가 3개 이상 동일 하면 제외 함)
                    MaxSeriesNumber = 3,                                                // 일련 번호 갯수(3자리 이상 번호가 연번이면 제외 함)

                    MaxSameDigits  = 4,                                                 // 과거 당첨 번호 중 같은 번호가 출현한 갯수
                    MaxSameJackpot = 3,                                                 // 같은 번호가 3회 이상 발생 한 흔적이 거의 없음

                    NoJackpot1 = 0,
                    NoJackpot2 = 0,
                    NoJackpot3 = 0,
                    NoJackpot4 = 0,
                    NoJackpot5 = 0,

                    WinningAmount1 = 0m,
                    WinningAmount2 = 0m,
                    WinningAmount3 = 0m,
                    WinningAmount4 = 0m,
                    WinningAmount5 = 0m
                };

                ltctx.tb_lion_factor.Add(_new_factor);
                _factor = _new_factor;
            }

            return(_factor);
        }
Esempio n. 2
0
        public async Task SendLottoZipFile(string zip_file_path, dChoice choice, mWinner winner, mMember member, mFactor curr_factor, mFactor last_factor, mJackpot last_jackpot)
        {
            var _message = new MimeMessage();
            {
                _message.From.Add(new MailboxAddress(MailSenderName, MailSenderAddress));
                _message.To.Add(new MailboxAddress(member.LoginName, member.EmailAddress));

                _message.Subject = $"[로또번호] {member.LoginName} 님을 위한 [{choice.sequence_no}]회차 로또645 예측 번호 제공 {(member.IsDirectSend ? "D" : "I")}";
            }

            var _curr_no_combination = curr_factor.LNoCombination + curr_factor.RNoCombination;
            var _curr_no_extraction  = curr_factor.LNoExtraction + curr_factor.RNoExtraction;
            var _last_no_extraction  = last_factor.LNoExtraction + last_factor.RNoExtraction;

            var _builder = new BodyBuilder();

            {
                _builder.HtmlBody = $"<div>"
                                    + $"<h4>안녕하세요 '{member.LoginName}'님, '로또645 예측 번호 제공 서비스' 입니다.</h4>"
                                    + $"<p></p>"
                                    + $"<h4>A. [{last_jackpot.SequenceNo}]회 추첨 결과</h4>"
                                    + $"<p>당첨번호: <strong>{winner.Digit1}, {winner.Digit2}, {winner.Digit3}, {winner.Digit4}, {winner.Digit5}, {winner.Digit6} ({winner.Digit7})</strong></p>"
                                    + $"<p>예측결과: {_last_no_extraction:#,##0} 게임</p>"
                                    + $"<ul>"
                                    + $"<li>1등: {last_factor.NoJackpot1,10:#,##0} 게임, {last_factor.WinningAmount1,15:#,##0} 원</li>"
                                    + $"<li>2등: {last_factor.NoJackpot2,10:#,##0} 게임, {last_factor.WinningAmount2,15:#,##0} 원</li>"
                                    + $"<li>3등: {last_factor.NoJackpot3,10:#,##0} 게임, {last_factor.WinningAmount3,15:#,##0} 원</li>"
                                    + $"<li>4등: {last_factor.NoJackpot4,10:#,##0} 게임, {last_factor.WinningAmount4,15:#,##0} 원</li>"
                                    + $"<li>5등: {last_factor.NoJackpot5,10:#,##0} 게임, {last_factor.WinningAmount5,15:#,##0} 원</li>"
                                    + $"</ul>"
                                    + $"<p>회원결과: {last_jackpot.NoChoice} 게임</p>"
                                    + $"<ul>"
                                    + $"<li>지난 주 발송 된 번호 중 {last_jackpot.NoJackpot} 게임, <strong>{last_jackpot.WinningAmount:#,##0}원</strong>이 당첨 되었습니다.</li>"
                                    + $"</ul>"
                                    + $"<h4>B. [{choice.sequence_no}]회 예측 번호</h4>"
                                    + $"<ul>"
                                    + $"<li>전체 45개의 번호 중 <strong>{_curr_no_combination:#,##0}개의 게임</strong>을 조합 했습니다.</li>"
                                    + $"<li>그 중 확률적으로 의미 있는 <strong>{_curr_no_extraction:#,##0}개의 게임</strong>이 추출 되었습니다.</li>"
                                    + $"<li>'{member.LoginName}'님에게 추출 된 {_curr_no_extraction:#,##0}개의 게임 중, 엄선해서 <strong>{choice.no_choice:#,##0}개의 게임</strong>을 보내 드립니다.</li>"
                                    + $"<li>특별히 원하시는 번호(3개 까지)를 아래 [운영자] 메일로 알려 주시면, 해당 번호가 포함 되어 있는 게임만 받을 수 있습니다.</li>"
                                    + $"<li> <a href='https://play.google.com/store/apps/details?id=kr.co.odinsoftware.LION'>로또사자(Android)</a>, "
                                    + $"<a href='https://itunes.apple.com/us/app/%EB%A1%9C%EB%98%90%EC%82%AC%EC%9E%90-lottolion/id1236106275?l=ko&ls=1&mt=8'>로또사자(iOS)</a> "
                                    + $"앱을 설치 하시면, 당첨내역과 이력 조회 및 게임 수 변경, 번호 지정이 가능 합니다.</li>"
                                    + $"</ul>"
                                    + $"<h4>C. 출력 방법</h4>"
                                    + $"<ul>"
                                    + $"<li>이미지 파일을 A4 프린터로 출력 후 로또 용지 크기와 동일하게 절단 합니다.</li>"
                                    + $"<li>A4 한장 당 최대 로또 용지 3장이 출력 됩니다.</li>"
                                    + $"<li>절취선에 맞춰 절단 후 로또 판매점에서 별도로 작성 하지 않고, 출력하신 용지로 바로 구매 가능 합니다.</li>"
                                    + $"<li>절취시 잘못 절단 하면 로또 판매점의 리더기에서 오류가 발생 할 수 있습니다.</li>"
                                    + $"<li>실제 로또 용지와 크기가 동일하게 절단하는 것이 중요 합니다.</li>"
                                    + $"<li>길이(19cm) 및 높이(8.2cm)는 같거나 조금 작아야 오류가 없습니다.</li>"
                                    + $"</ul>"
                                    + $"<h4>D. 회원 가입</h4>"
                                    + $"<ul>"
                                    + $"<li>매주 무료 예측 번호를 원하시는 주변 분이 있는 경우 '메일주소'와 '닉네임'을 아래 [운영자] 메일로 보내 주세요.</li>"
                                    + $"<li>메일 수신을 원하지 않는 경우에도 [운영자]에게 제목을 '수신거부'로 메일 보내 주시면 바로 중단 해 드립니다.</li>"
                                    + $"</ul>"
                                    + $"<h4>E. 연락처</h4>"
                                    + $"<ul>"
                                    + $"<li>회사명: {ServiceProvider}</li>"
                                    + $"<li>연락처: {ServiceProviderPhone}</li>"
                                    + $"<li>사이트: <a href='{ServiceProviderHomePage}'>{ServiceProviderHomePage}</a></li>"
                                    + $"<li>운영자: <a href='mailto:{ServiceProviderMailTo}'>{ServiceProviderMailTo}</a></li>"
                                    + $"</ul>"
                                    + "</div>"
                ;

                _builder.Attachments.Add(zip_file_path);
            }

            _message.Body = _builder.ToMessageBody();

            if (member.IsDirectSend == false)
            {
                using (var _client = new SmtpClient())
                {
                    _client.ServerCertificateValidationCallback = (s, c, h, e) => true;

                    _client.Connect(MailDeliveryServer, MailDeliveryPort, false);

                    // Note: since we don't have an OAuth2 token, disable
                    // the XOAUTH2 authentication mechanism.
                    _client.AuthenticationMechanisms.Remove("XOAUTH2");

                    // Note: only needed if the SMTP server requires authentication
                    _client.Authenticate(MailDeliveryUserName, MailDeliveryUserPassword);

                    _client.Send(_message);
                    _client.Disconnect(true);
                }
            }
            else
            {
                await __smtp_direct.SendMailAsync(_message);
            }
        }
Esempio n. 3
0
        public int SelectScoring(AppDbContext ltctx, mWinner winner, mFactor factor, List <short> winner_digits)
        {
            var _no_jackpot = 0;

            // clear
            {
                factor.NoJackpot1     = 0;
                factor.WinningAmount1 = 0;

                factor.NoJackpot2     = 0;
                factor.WinningAmount2 = 0;

                factor.NoJackpot3     = 0;
                factor.WinningAmount3 = 0;

                factor.NoJackpot4     = 0;
                factor.WinningAmount4 = 0;

                factor.NoJackpot5     = 0;
                factor.WinningAmount5 = 0;
            }

            var _selects = ltctx.tb_lion_select
                           .Where(x => x.SequenceNo == winner.SequenceNo && x.Ranking == 0)
                           .ToList();

            foreach (var _s in _selects)
            {
                var _select_digits = new List <short>();
                {
                    _select_digits.Add(_s.Digit1);
                    _select_digits.Add(_s.Digit2);
                    _select_digits.Add(_s.Digit3);
                    _select_digits.Add(_s.Digit4);
                    _select_digits.Add(_s.Digit5);
                    _select_digits.Add(_s.Digit6);
                }

                var _match_count = 0;
                foreach (var _x in _select_digits)
                {
                    if (winner_digits.Exists(x => x == _x) == true)
                    {
                        _match_count++;
                    }
                }

                _no_jackpot++;

                if (_match_count >= 6)
                {
                    _s.Ranking = 1;
                    _s.Amount  = winner.Amount1;

                    factor.NoJackpot1++;
                    factor.WinningAmount1 += winner.Amount1;
                }
                else if (_match_count >= 5)
                {
                    if (_select_digits.Exists(x => x == winner.Digit7) == true)
                    {
                        _s.Ranking = 2;
                        _s.Amount  = winner.Amount2;

                        factor.NoJackpot2++;
                        factor.WinningAmount2 += winner.Amount2;
                    }
                    else
                    {
                        _s.Ranking = 3;
                        _s.Amount  = winner.Amount3;

                        factor.NoJackpot3++;
                        factor.WinningAmount3 += winner.Amount3;
                    }
                }
                else if (_match_count >= 4)
                {
                    _s.Ranking = 4;
                    _s.Amount  = winner.Amount4;

                    factor.NoJackpot4++;
                    factor.WinningAmount4 += winner.Amount4;
                }
                else if (_match_count >= 3)
                {
                    _s.Ranking = 5;
                    _s.Amount  = winner.Amount5;

                    factor.NoJackpot5++;
                    factor.WinningAmount5 += winner.Amount5;
                }
                else
                {
                    _no_jackpot--;

                    // 낙첨(6위) select(추출) 번호는 삭제 함
                    ltctx.tb_lion_select.Remove(_s);
                }
            }

            return(_no_jackpot);
        }
Esempio n. 4
0
        /// <summary>
        /// 번호를 추출 합니다. 숫자 선택 후 제외 시키는 방법으로 처리 하게 됩니다.
        /// </summary>
        /// <param name="ltctx"></param>
        /// <param name="factor"></param>
        /// <returns></returns>
        public int WinnerSelect(AppDbContext ltctx, mFactor factor)
        {
            var _analysies = ltctx.tb_lion_analysis
                             .Where(x => x.SequenceNo < factor.SequenceNo)
                             .OrderBy(x => x.SequenceNo)
                             .ToArray();

            var _sum_odd_even = EvenOddBalance(_analysies, factor.SequenceNo);
            var _sum_high_low = HighLowBalance(_analysies, factor.SequenceNo);

            var _sum_balances = _analysies
                                .GroupBy(x => x.SumFrequence)
                                .Select(
                y => new dKeyValue
            {
                key   = y.Key,
                value = y.Count()
            }
                )
                                .ToList();

            var _filter = new dFilter
            {
                sequence_no = factor.SequenceNo,

                is_left_selection = false,
                start_select_no   = 0,

                elects          = new List <dDigits>(),
                sampling_digits = null,

                analysies = _analysies,
                factor    = factor,

                sum_balances = _sum_balances,

                sum_odd  = _sum_odd_even.sum_odd,
                sum_even = _sum_odd_even.sum_even,
                sum_high = _sum_high_low.sum_high,
                sum_low  = _sum_high_low.sum_low
            };

            // 좌측
            var _left_samplings = GetLNumbereByPercent(_analysies, factor.SequenceNo, factor.LNoSampling);
            {
                _filter.is_left_selection = true;
                _filter.sampling_digits   = _left_samplings;

                if (_left_samplings.Length > 0)
                {
                    var _selection = WinnerElect(ltctx, _filter);
                    _filter.start_select_no += _selection.no_select;

                    factor.LNoCombination = _selection.no_combine;
                    factor.LNoExtraction  = _selection.no_select;
                }
            }

            // 우측
            var _right_samplings = GetRNumbereByPercent(_analysies, factor.SequenceNo, factor.RNoSampling);

            {
                _filter.is_left_selection = false;
                _filter.sampling_digits   = _right_samplings;

                if (_right_samplings.Length > 0)
                {
                    var _selection = WinnerElect(ltctx, _filter);
                    _filter.start_select_no += _selection.no_select;

                    factor.RNoCombination = _selection.no_combine;
                    factor.RNoExtraction  = _selection.no_select;
                }
            }

            // shuffle
            WinnerShuffle(_filter);

            // write to db
            return(WinnerWrite(ltctx, _filter));
        }