Beispiel #1
0
        public async Task Seed(WwwContext context, WwwCreate NewRun = null)
        {
            Random rng = new Random();

            List <DateTime> dates = new List <DateTime>();
            DateTime        edate = DateTime.Today;

            for (int i = 0; i < 60; i++)
            {
                dates.Add(edate);
                edate.AddDays(-1);
            }


            for (int i = 0; i < 1000; i++)
            {
                EntityRunFormData data = new EntityRunFormData();
                WwwWalk           walk = context.wwwWalks.Include(i => i.WwwSchools).First(f => f.isActive == true);
                data.Walk   = walk.Name;
                data.School = walk.WwwSchools.First().Name;
                int index = rng.Next(WwwData.s_classes.Length);
                data.SchoolClass = WwwData.s_classes[index];
                data.Distance    = (float)rng.Next(1, 41);
                data.Identifier  = Guid.NewGuid().ToString("N");
                index            = rng.Next(dates.Count);
                data.Time        = dates[index];

                var ent = await Submit(context, data, true);
            }

            await context.SaveChangesAsync();
        }
Beispiel #2
0
        public async Task <WwwFeedback> Submit(EntityRunFormData formData)
        {
            WwwFeedback         feedback = null;
            HttpResponseMessage response = null;

            if (isAdmin)
            {
                isAdmin = false;
            }
            try
            {
                response = await Http.PostAsJsonAsync <EntityRunFormData>("api/submit", formData);
            } catch (Exception e)
            {
                logger.LogError(e.Message);
                return(feedback);
            }

            if (response.IsSuccessStatusCode)
            {
                try
                {
                    var content = await response.Content.ReadAsStringAsync();

                    if (!String.IsNullOrEmpty(content))
                    {
                        feedback = JsonSerializer.Deserialize <WwwFeedback>(content, new JsonSerializerOptions {
                            PropertyNameCaseInsensitive = true
                        });
                    }
                }
                catch (Exception e)
                {
                    logger.LogError(e.Message);
                }
                if (feedback.EntPosition == 1337 && feedback.SchoolTotal == 1337)
                {
                    isAdmin = true;
                    return(null);
                }
            }
            return(feedback);
        }
Beispiel #3
0
 public async Task <WwwFeedback> Submit(EntityRunFormData entry)
 {
     return(await db.Submit(context, entry));
 }
Beispiel #4
0
        public async Task <WwwFeedback> Submit(WwwContext context, EntityRunFormData data, bool bulk = false)
        {
            if (data.Identifier == WwwData.Admin && data.Credential == WwwData.AdminCredential)
            {
                return new WwwFeedback()
                       {
                           EntPosition = 1337,
                           SchoolTotal = 1337
                       }
            }
            ;

            if (data.Credential != WwwData.Credential)
            {
                return new WwwFeedback()
                       {
                           EntPosition = -1
                       }
            }
            ;

            await semaphoreSlim.WaitAsync();

            WwwEntity ent = null;

            try
            {
                var walk = await context.wwwWalks.FirstAsync(f => f.Name == WwwData.s_walk);

                // var school = await context.wwwSchools.FirstAsync(f => f.Name == WwwData.s_school);
                var school = await context.wwwSchools.FirstAsync(f => f.WwwWalk == walk);

                WwwClass wwwClass = await context.wwwClasses.FirstOrDefaultAsync(f => f.Name == data.SchoolClass);

                WwwEntity entity = await context.wwwEntities
                                   .Include(i => i.WwwClass)
                                   .FirstOrDefaultAsync(f => f.Pseudonym == data.Identifier);

                if (wwwClass == null)
                {
                    if (wwwClass == null)
                    {
                        wwwClass           = new WwwClass();
                        wwwClass.WwwSchool = school;
                        wwwClass.Name      = data.SchoolClass;
                        wwwClass.Year      = 0;
                        string year = String.Empty;
                        for (int i = 0; i < wwwClass.Name.Length; i++)
                        {
                            if (Char.IsDigit(wwwClass.Name[i]))
                            {
                                year += wwwClass.Name[i];
                            }
                            else
                            {
                                break;
                            }
                        }
                        int iyear = 0;
                        if (int.TryParse(year, out iyear))
                        {
                            wwwClass.Year = iyear;
                        }
                        context.wwwClasses.Add(wwwClass);
                    }
                    await context.SaveChangesAsync();
                }

                if (entity == null)
                {
                    entity                     = new WwwEntity();
                    wwwClass.WwwSchool         = school;
                    wwwClass.WwwSchool.WwwWalk = walk;
                    entity.WwwClass            = wwwClass;
                    entity.Pseudonym           = data.Identifier;
                    context.wwwEntities.Add(entity);

                    wwwClass.TotalEntities++;
                    school.TotalEntities++;
                    walk.TotalEntities++;
                }

                if (entity.WwwClass == wwwClass)
                {
                    WwwRun run = new WwwRun();
                    run.WwwEntity = entity;
                    run.Time      = data.Time;
                    run.Distance  = data.Distance;

                    context.wwwRuns.Add(run);

                    entity.TotalRuns   += run.Distance;
                    wwwClass.TotalRuns += run.Distance;
                    school.TotalRuns   += run.Distance;
                    walk.TotalRuns     += run.Distance;

                    entity.Runs++;

                    if (bulk == false)
                    {
                        await context.SaveChangesAsync();

                        return(await GetFeedback(context, walk, school, wwwClass, entity));
                    }
                    else
                    {
                        ent = entity;
                        return(null);
                    }
                }
                else
                {
                    return(new WwwFeedback()
                    {
                        EntPosition = -2
                    });
                }
            }
            catch (Exception e)
            {
                logger.LogError(e.Message);
            }
            finally
            {
                semaphoreSlim.Release();
            }
            return(null);
        }
Beispiel #5
0
 protected override void OnInitialized()
 {
     formData    = new EntityRunFormData();
     editContext = new EditContext(formData);
     base.OnInitialized();
 }