public async Task Add(int productId, int addressId, int types)
 {
     this.DbSet.Add(new ProductFBO
     {
         FboTypes  = (FboTypes)types,
         AddressId = addressId,
         ProductId = productId
     });
     await ctx.SaveChangesAsync();
 }
Exemple #2
0
        /// <summary>
        /// Add can be done in various situations Tags optional, but 0 must be atleast passed.
        /// </summary>
        /// <param name="hostId"></param>
        /// <param name="note"></param>
        /// <returns></returns>
        public async Task <SimsNote> Add(int hostId, string note, int tags)
        {
            var newComment = new NoteDb {
                Note = note, HostId = hostId, TagFlags = tags
            };

            this.NoteSet.Add(newComment);
            var incident = this.NoteSet.SingleOrDefault(p => p.Id == hostId);
            await ctx.SaveChangesAsync();

            return(mapper.Map <NoteDb, SimsNote>(newComment));
        }
Exemple #3
0
        public async Task <SimsAttachmentFileInfo> Add(int hostId, string docUrl, int tags = 0)
        {
            var newItem = this.DbSet.Add(new AttachmentDb
            {
                DocUrl   = docUrl,
                HostId   = hostId,
                TagFlags = (DocumentTagTypes)tags
            });

            await ctx.SaveChangesAsync();

            return(mapper.Map <AttachmentDb, SimsAttachmentFileInfo>(newItem.Entity));
        }
Exemple #4
0
        public async Task <SimsProduct> Add(int HostId, SimsProduct newProduct)
        {
            if (HostId == 0)
            {
                throw new ArgumentOutOfRangeException("No host selected.");
            }
            var dbItem = mapper.Map <SimsProduct, T>(newProduct);

            dbItem.HostId = HostId;
            var dbCreated = DbSet.Add(dbItem);
            await ctx.SaveChangesAsync();

            return(mapper.Map <T, SimsProduct>(dbCreated.Entity));
        }
        /// <summary>
        /// Update only a classification in an incident
        /// </summary>
        /// <param name="id"></param>
        /// <param name="ClassificationId"></param>
        /// <returns>
        /// The updated incident
        /// </returns>
        /// <exception cref="NullReferenceException" />
        public async Task <BaseIncident> UpdateClassification(int id, int ClassificationId)
        {
            if (await this.IsClosed(id))
            {
                throw new ArgumentOutOfRangeException("Cannot update a closed incident.");
            }

            var dbItem = await ctx.Incidents.FindAsync(id);

            dbItem.ClassificationId = ClassificationId;
            await ctx.SaveChangesAsync();

            return(mapper.Map <IncidentDb, BaseIncident>(dbItem));
        }
        /// <summary>
        /// TO DO !!!!
        /// </summary>
        /// <param name="address"></param>
        /// <returns></returns>
        public async Task <SimsAddress> Update(SimsAddress address)
        {
            var dbItem = await ctx.Addresses.Include(i => i.Contacts).SingleAsync(s => s.Id == address.Id);

            // Updates the address details
            this.mapper.Map(address, dbItem);
            //address.ToDb(dbItem);

            ctx.Addresses.Update(dbItem);
            // Main Contact. We don't have the key for contacins.
            // Currently (25/08/2020) you may only add one contact.
            // so hear we either update an existing contact (is always main), or add a new one.
            if (address.Contacts.Count() > 0)
            {
                var firstContact = address.Contacts.First();
                if (dbItem.Contacts.Count() > 0)
                {
                    var dbContact = dbItem.Contacts.First();
                    this.mapper.Map(firstContact, dbContact);
                    //firstContact.ToDb(dbContact);
                }
                else
                {
                    var newDbContact = mapper.Map <SimsAddressContact, AddressContactDb>(firstContact);
                    dbItem.Contacts.Add(newDbContact);
                }
                await ctx.SaveChangesAsync();
            }

            return(mapper.Map <AddressDb, SimsAddress>(dbItem));
        }
 public async Task AddBatch(IEnumerable <SimsSignal> signals)
 {
     foreach (var signal in signals)
     {
         var dbItem = this.ToDb(signal);
         this.ctx.Signals.Add(dbItem);
     }
     await ctx.SaveChangesAsync();
 }
Exemple #8
0
        public async Task <SimsStakeholder> Add(int hostId, SimsStakeholder stakeholder)
        {
            if (hostId == 0)
            {
                throw new ArgumentOutOfRangeException("Host Id missing.");
            }

            if (stakeholder.Id > 0)
            {
                throw new ArgumentException("Stakeholder already exists.");
            }
            // Cannot add an FSA member with an address, this is an application error.
            stakeholder.HostId = hostId;
            var toDb   = mapper.Map <SimsStakeholder, T>(stakeholder);
            var dbItem = this.DbSet.Add(toDb);

            await ctx.SaveChangesAsync();

            return(this.mapper.Map <T, SimsStakeholder>(dbItem.Entity));
        }
        public Task LogEntry(string IncidentOrSignal, string PageRef, int ItemId)
        {
            ctx.UserAccessLog.Add(new UserAccessAuditDb
            {
                UserId  = ctx.Editor,
                Scope   = IncidentOrSignal,
                Page    = PageRef,
                ScopeId = ItemId
            });

            return(ctx.SaveChangesAsync());
        }
Exemple #10
0
        public async Task <SimsOnlineForm> Add(SimsOnlineForm onlineForm)
        {
            var newEntity = mapper.Map <OnlineFormDb>(onlineForm);
            var ent       = await ctx.AddAsync(newEntity);

            await ctx.SaveChangesAsync();

            return(mapper.Map <SimsOnlineForm>(ent.Entity));
        }
Exemple #11
0
        public async Task <SimsLinkedRecord> Remove(int from, int to)
        {
            // LOcal functions fancy.
            // Cos the logic is annoying and I'm not confident in it yet.
            // Why should we update the host object?
            async Task <SimsLinkedRecord> DeleteLink(LinkDb link)
            {
                this.LinkSet.Remove(link);
                //var fromIncident = this.LinkSet.Find(link.FromId);
                //var toincident = this.LinkSet.Find(link.ToId);

                await ctx.SaveChangesAsync();

                return(new SimsLinkedRecord {
                    From = from, To = to
                });
            }

            var linkData = this.LinkSet.Find(from, to);

            if (linkData == null)
            {
                // try the other way instead to-from
                linkData = this.LinkSet.Find(to, from);
            }
            if (linkData != null)
            {
                return(await DeleteLink(linkData));
            }
            else
            {
                return new SimsLinkedRecord {
                           From = 0, To = 0
                }
            };
        }