Esempio n. 1
0
        public async Task <Result> TryCreate(Android android)
        {
            if (!android.IsValid)
            {
                return(new Result(false, "Android wasn`t created"));
            }
            if (await IsAndroid(android.Name))
            {
                return(new Result(false, "Android with this name already exists"));
            }

            if (android.Skills.Where(s => !s.IsValid).Count() > 0)
            {
                return(new Result(false, "Android wasn`t created: skill error"));
            }

            AndroidEntity androidEntity = new AndroidEntity {
                Name = android.Name, Reliability = 10, Status = true, Avatar = android.Avatar
            };

            JobEntity job = await _context.Jobs.FirstOrDefaultAsync(j => j.Id == android.JobId);

            if (job == null)
            {
                return(new Result(false, "Android wasn`t created: job error"));
            }

            androidEntity.Job = job;

            SkillEntity skillEntity;
            List <SkillToAndroidEntity> StoAs = new List <SkillToAndroidEntity>();

            foreach (Skill s in android.Skills)
            {
                skillEntity = await _context.Skills.FirstOrDefaultAsync(e => e.Name == s.Name);

                StoAs.Add(new SkillToAndroidEntity {
                    Skill = skillEntity, Android = androidEntity
                });
            }

            await _context.Androids.AddAsync(androidEntity);

            await _context.SaveChangesAsync();

            await _context.Entry(androidEntity).Collection(a => a.SkillsToAndroids).LoadAsync();

            foreach (SkillToAndroidEntity s in StoAs)
            {
                androidEntity.SkillsToAndroids.Add(s);
            }

            _context.Update(androidEntity);
            await _context.SaveChangesAsync();

            return(new Result(true));
        }
Esempio n. 2
0
        public async Task <Result> TryDelete(int id)
        {
            AndroidEntity android = await _context.Androids.FirstOrDefaultAsync(a => a.Id == id);

            if (android == null)
            {
                return(new Result(false, "Can`t find android with current id"));
            }

            _context.Androids.Remove(android);
            await _context.SaveChangesAsync();

            return(new Result(true));
        }
Esempio n. 3
0
        protected override void OnCreate(Bundle savedInstanceState)
        {
            TabLayoutResource = Resource.Layout.Tabbar;
            ToolbarResource   = Resource.Layout.Toolbar;
            base.OnCreate(savedInstanceState);

            Forms.SetFlags("CollectionView_Experimental");
            Forms.Init(this, savedInstanceState);
            UserDialogs.Init(this);
            AnimationViewRenderer.Init();
            CachedImageRenderer.Init(false);
            AndroidEntity.Init(this, savedInstanceState);
            CarouselView.FormsPlugin.Android.CarouselViewRenderer.Init();

            RegisterDependencies();
            LoadApplication(new App());
        }
Esempio n. 4
0
        public async Task <Result> TryUpdate(int id, Android android)
        {
            if (!android.IsValid)
            {
                return(new Result(false, "Android wasn`t updated"));
            }

            AndroidEntity androidEntity = await _context.Androids.SingleOrDefaultAsync(a => a.Id == id);

            if (androidEntity == null)
            {
                return(new Result(false, "Can`t find android with current id"));
            }

            if (androidEntity.Reliability > 0)
            {
                JobEntity job = await _context.Jobs.SingleOrDefaultAsync(j => j.Id == android.JobId);

                if (job == null)
                {
                    return(new Result(false, "Android wasn`t updated: job error"));
                }

                if (job != androidEntity.Job)
                {
                    androidEntity.Reliability--;

                    if (androidEntity.Reliability <= 0)
                    {
                        androidEntity.Status = false;
                    }

                    androidEntity.Job = job;
                }
            }

            androidEntity.Name   = android.Name;
            androidEntity.Avatar = android.Avatar;

            List <SkillEntity> skillEntities = new List <SkillEntity>();
            SkillEntity        currEntity;

            foreach (Skill s in android.Skills)
            {
                if (!s.IsValid)
                {
                    return(new Result(false, "Android wasn`t updated: skill error"));
                }

                currEntity = await _context.Skills.FirstOrDefaultAsync(e => e.Name == s.Name);

                if (currEntity == null)
                {
                    return(new Result(false, "Android wasn`t updated: skill error"));
                }

                skillEntities.Add(currEntity);
            }

            await _context.Entry(androidEntity).Collection(a => a.SkillsToAndroids).LoadAsync();

            androidEntity.SkillsToAndroids.Clear();
            foreach (SkillEntity e in skillEntities)
            {
                androidEntity.SkillsToAndroids.Add(new SkillToAndroidEntity {
                    Android = androidEntity, Skill = e
                });
            }

            _context.Update(androidEntity);
            await _context.SaveChangesAsync();

            return(new Result(true));
        }