public void editMOABasicInfo(int moa_id, MOABasicInfo newBasicInfo)
        {
            using (DbContextTransaction transaction = db.Database.BeginTransaction())
            {
                try
                {
                    //update basicInfo
                    MOA moa = db.MOAs.Find(moa_id);
                    moa.moa_code        = newBasicInfo.moa_code;
                    moa.moa_end_date    = newBasicInfo.moa_end_date;
                    moa.moa_note        = newBasicInfo.moa_note;
                    moa.evidence        = newBasicInfo.evidence;
                    db.Entry(moa).State = EntityState.Modified;
                    db.SaveChanges();

                    db.MOAStatusHistories.Add(new MOAStatusHistory
                    {
                        mou_status_id = newBasicInfo.moa_status_id,
                        reason        = newBasicInfo.reason,
                        moa_id        = moa_id,
                        datetime      = DateTime.Now
                    });

                    db.SaveChanges();
                    transaction.Commit();
                }
                catch (Exception ex)
                {
                    transaction.Rollback();
                    throw ex;
                }
            }
        }
示例#2
0
        public void editMOUBasicInfo(int mou_id, MOUBasicInfo newBasicInfo)
        {
            using (DbContextTransaction transaction = db.Database.BeginTransaction())
            {
                try
                {
                    DateTime mou_end_date = DateTime.ParseExact(newBasicInfo.mou_end_date_string, "dd/MM/yyyy", CultureInfo.InvariantCulture);
                    //update basicInfo
                    MOU mou = db.MOUs.Find(mou_id);
                    mou.mou_code        = newBasicInfo.mou_code;
                    mou.mou_end_date    = mou_end_date;
                    mou.mou_note        = newBasicInfo.mou_note;
                    mou.evidence        = newBasicInfo.evidence;
                    mou.office_id       = newBasicInfo.office_id;
                    db.Entry(mou).State = EntityState.Modified;
                    db.SaveChanges();

                    //update MOUStatusHistory
                    MOUStatusHistory m = new MOUStatusHistory();
                    m.mou_status_id = newBasicInfo.mou_status_id;
                    m.reason        = newBasicInfo.reason;
                    m.mou_id        = mou_id;
                    m.datetime      = DateTime.Now;
                    db.MOUStatusHistories.Add(m);
                    db.SaveChanges();
                    transaction.Commit();
                }
                catch (Exception ex)
                {
                    transaction.Rollback();
                    throw ex;
                }
            }
            return;
        }
示例#3
0
 public string getAccount(ENTITIES.CustomModels.Authen.Gmail user)
 {
     try
     {
         Account obj = db.Accounts.Where(x => x.email.Equals(user.email)).FirstOrDefault();
         if (obj == null)
         {
             return(String.Empty);
         }
         Account a = new Account()
         {
             email     = user.email,
             full_name = user.name,
             google_id = user.id,
             picture   = user.imageurl
         };
         db.Entry(a).State = EntityState.Modified;
         db.SaveChanges();
         string url = a.Role.role_name;
         return(url);
     }
     catch (Exception e)
     {
         return(String.Empty);
     }
 }
示例#4
0
 public bool edit(infoRight obj)
 {
     try
     {
         using (ScienceAndInternationalAffairsEntities db = new ScienceAndInternationalAffairsEntities())
         {
             db.Configuration.LazyLoadingEnabled = false;
             Right r = db.Rights.Find(obj.right_id);
             r.right_name      = obj.right_name;
             r.module_id       = int.Parse(obj.module_name);
             r.group_id        = obj.group_id;
             db.Entry(r).State = EntityState.Modified;
             db.SaveChanges();
             return(true);
         }
     }
     catch (Exception e)
     {
         return(false);
     }
 }
示例#5
0
        public void addMOA(MOAAdd input, int mou_id)
        {
            using (DbContextTransaction transaction = db.Database.BeginTransaction())
            {
                try
                {
                    //add MOA
                    //add MOAPartner =>
                    //update PartnerScope =>
                    //add MOAPartnerScope
                    //add MOAStatusHistory
                    DateTime moa_end_date = DateTime.ParseExact(input.MOABasicInfo.moa_end_date, "dd/MM/yyyy", CultureInfo.InvariantCulture);
                    MOA      m            = db.MOAs.Add(new MOA
                    {
                        moa_code     = input.MOABasicInfo.moa_code,
                        moa_end_date = moa_end_date,
                        moa_note     = input.MOABasicInfo.moa_note,
                        mou_id       = mou_id,
                        account_id   = 1,
                        add_time     = DateTime.Now,
                        is_deleted   = false
                    });
                    //checkpoint 1
                    db.SaveChanges();

                    foreach (MOAPartnerInfo item in input.MOAPartnerInfo.ToList())
                    {
                        db.MOAPartners.Add(new MOAPartner
                        {
                            moa_id         = m.moa_id,
                            moa_start_date = DateTime.ParseExact(item.sign_date_moa_add, "dd/MM/yyyy", CultureInfo.InvariantCulture),
                            partner_id     = item.partner_id
                        });
                        foreach (int scopeItem in item.coop_scope_add.ToList())
                        {
                            PartnerScope ps = db.PartnerScopes.Where(x => x.partner_id == item.partner_id && x.scope_id == scopeItem).First();
                            ps.reference_count -= 1;

                            db.Entry(ps).State = EntityState.Modified;
                            db.MOAPartnerScopes.Add(new MOAPartnerScope
                            {
                                partner_scope_id = ps.partner_scope_id,
                                moa_id           = m.moa_id
                            });
                        }
                        //checkpoint 2
                        db.SaveChanges();
                    }
                    db.MOAStatusHistories.Add(new MOAStatusHistory
                    {
                        datetime      = DateTime.Now,
                        reason        = input.MOABasicInfo.reason,
                        moa_id        = m.moa_id,
                        mou_status_id = 2
                    });
                    //checkpoint 3
                    db.SaveChanges();
                    transaction.Commit();
                }
                catch (Exception ex)
                {
                    transaction.Rollback();
                    throw ex;
                }
            }
        }
示例#6
0
        public void editMOAPartner(MOAPartnerEdited input, int moa_id)
        {
            using (DbContextTransaction transaction = db.Database.BeginTransaction())
            {
                try
                {
                    DateTime sign_date = DateTime.ParseExact(input.sign_date_string, "dd/MM/yyyy", CultureInfo.InvariantCulture);
                    //edit MOAPartner
                    MOAPartner mp = db.MOAPartners.Where(x => x.moa_partner_id == input.moa_partner_id).First();
                    mp.moa_start_date  = sign_date;
                    mp.partner_id      = db.Partners.Where(x => x.partner_name == input.partner_name).First().partner_id;
                    db.Entry(mp).State = EntityState.Modified;
                    db.SaveChanges();

                    //get old records of PartnerScope in MOA
                    string sql_old_partnerScope   = @"select t1.partner_scope_id,partner_id,scope_id from IA_Collaboration.PartnerScope t1 inner join 
                        IA_Collaboration.MOAPartnerScope t2 on
                        t1.partner_scope_id = t2.partner_scope_id
                        where moa_id = @moa_id";
                    List <PartnerScope> listOldPS = db.Database.SqlQuery <PartnerScope>(sql_old_partnerScope,
                                                                                        new SqlParameter("moa_id", moa_id)).ToList();

                    //reset old records of scopes of partner.
                    foreach (PartnerScope token in listOldPS.ToList())
                    {
                        PartnerScope objPS = db.PartnerScopes.Where(x => x.partner_scope_id == token.partner_scope_id).First();
                        //decrese refer_count in PartnerScope
                        objPS.reference_count -= 1;
                        db.Entry(objPS).State  = EntityState.Modified;

                        //delete record of MOUPartnerScope.
                        db.MOAPartnerScopes.Remove(db.MOAPartnerScopes.Where(x => x.partner_scope_id == token.partner_scope_id).First());
                    }

                    //add new records of scopes of partner.
                    foreach (int tokenScope in input.scopes.ToList())
                    {
                        PartnerScope objPS            = db.PartnerScopes.Where(x => x.partner_id == mp.partner_id && x.scope_id == tokenScope).FirstOrDefault();
                        int          partner_scope_id = 0;
                        if (objPS == null) //add new to PartnerScope
                        {
                            db.PartnerScopes.Add(new PartnerScope
                            {
                                partner_id      = mp.partner_id,
                                scope_id        = tokenScope,
                                reference_count = 0
                            });
                            //checkpoint 3
                            db.SaveChanges();
                            PartnerScope newObjPS = db.PartnerScopes.Where(x => x.partner_id == mp.partner_id && x.scope_id == tokenScope).FirstOrDefault();
                            partner_scope_id = newObjPS.partner_scope_id;
                        }
                        else
                        {
                            objPS.reference_count += 1;
                            db.Entry(objPS).State  = EntityState.Modified;
                            partner_scope_id       = objPS.partner_scope_id;
                        }
                        db.MOAPartnerScopes.Add(new MOAPartnerScope
                        {
                            partner_scope_id = partner_scope_id,
                            moa_id           = moa_id
                        });
                    }

                    db.SaveChanges();
                    transaction.Commit();
                }
                catch (Exception ex)
                {
                    transaction.Rollback();
                    throw ex;
                }
            }
        }
        public void addMOU(MOUAdd input)
        {
            using (DbContextTransaction transaction = db.Database.BeginTransaction())
            {
                try
                {
                    //add MOU
                    //Check Partner
                    //add MOUPartner =>
                    //check or add PartnerScope
                    //add MOUPartnerScope
                    //add MOUPartnerSpecialization
                    //add MOUStatusHistory
                    DateTime mou_end_date = DateTime.ParseExact(input.BasicInfo.mou_end_date, "dd/MM/yyyy", CultureInfo.InvariantCulture);
                    MOU      m            = new MOU
                    {
                        mou_code     = input.BasicInfo.mou_code,
                        mou_end_date = mou_end_date,
                        mou_note     = input.BasicInfo.mou_note,
                        evidence     = input.BasicInfo.evidence is null ? "" : input.BasicInfo.evidence,
                        office_id    = input.BasicInfo.office_id,
                        account_id   = 1,
                        add_time     = DateTime.Now,
                        is_deleted   = false,
                        noti_count   = 0
                    };
                    db.MOUs.Add(m);
                    //checkpoint 1
                    db.SaveChanges();
                    MOU objMOU = db.MOUs.Where(x => x.mou_code == input.BasicInfo.mou_code).First();

                    //Add MOUStatusHistory
                    db.MOUStatusHistories.Add(new ENTITIES.MOUStatusHistory
                    {
                        datetime      = DateTime.Now,
                        reason        = input.BasicInfo.reason,
                        mou_id        = objMOU.mou_id,
                        mou_status_id = input.BasicInfo.mou_status_id
                    });

                    foreach (PartnerInfo item in input.PartnerInfo.ToList())
                    {
                        int partner_id_item = 0;
                        //new partner
                        if (item.partner_id == 0)
                        {
                            db.Partners.Add(new ENTITIES.Partner
                            {
                                partner_name = item.partnername_add,
                                website      = item.website_add,
                                address      = item.address_add,
                                country_id   = 13
                            });
                            //checkpoint 2
                            db.SaveChanges();
                            ENTITIES.Partner objPartner = db.Partners.Where(x => x.partner_name == item.partnername_add).First();
                            partner_id_item = objPartner.partner_id;
                        }
                        else //old partner
                        {
                            partner_id_item = item.partner_id;
                        }
                        //add to MOUPartner via each partner of MOU
                        db.MOUPartners.Add(new ENTITIES.MOUPartner
                        {
                            mou_id              = objMOU.mou_id,
                            partner_id          = partner_id_item,
                            mou_start_date      = DateTime.ParseExact(item.sign_date_mou_add, "dd/MM/yyyy", CultureInfo.InvariantCulture),
                            contact_point_name  = item.represent_add,
                            contact_point_email = item.email_add,
                            contact_point_phone = item.phone_add
                        });
                        //PartnerScope and MOUPartnerScope
                        foreach (int tokenScope in item.coop_scope_add.ToList())
                        {
                            PartnerScope objPS            = db.PartnerScopes.Where(x => x.partner_id == partner_id_item && x.scope_id == tokenScope).FirstOrDefault();
                            int          partner_scope_id = 0;
                            if (objPS == null)
                            {
                                db.PartnerScopes.Add(new PartnerScope
                                {
                                    partner_id      = partner_id_item,
                                    scope_id        = tokenScope,
                                    reference_count = 0
                                });
                                //checkpoint 3
                                db.SaveChanges();
                                PartnerScope newObjPS = db.PartnerScopes.Where(x => x.partner_id == partner_id_item && x.scope_id == tokenScope).FirstOrDefault();
                                partner_scope_id = newObjPS.partner_scope_id;
                            }
                            else
                            {
                                objPS.reference_count += 1;
                                db.Entry(objPS).State  = EntityState.Modified;
                                partner_scope_id       = objPS.partner_scope_id;
                            }
                            db.MOUPartnerScopes.Add(new MOUPartnerScope
                            {
                                partner_scope_id = partner_scope_id,
                                mou_id           = objMOU.mou_id
                            });
                        }
                        //checkpoint 4
                        db.SaveChanges();
                        //MOUPartnerSpe
                        MOUPartner objMOUPartner = db.MOUPartners.Where(x => (x.mou_id == objMOU.mou_id && x.partner_id == partner_id_item)).First();
                        foreach (int tokenSpe in item.specialization_add.ToList())
                        {
                            db.MOUPartnerSpecializations.Add(new MOUPartnerSpecialization
                            {
                                mou_partner_id    = objMOUPartner.mou_partner_id,
                                specialization_id = tokenSpe,
                            });
                        }
                    }
                    db.SaveChanges();
                    transaction.Commit();
                }
                catch (Exception ex)
                {
                    transaction.Rollback();
                    throw ex;
                }
            }
        }
 public void addMOUPartner(PartnerInfo input, int mou_id)
 {
     using (DbContextTransaction transaction = db.Database.BeginTransaction())
     {
         try
         {
             int partner_id_item = 0;
             //new partner
             if (input.partner_id == 0)
             {
                 db.Partners.Add(new ENTITIES.Partner
                 {
                     partner_name = input.partnername_add,
                     website      = input.website_add,
                     address      = input.address_add,
                     country_id   = 13
                 });
                 //checkpoint 2
                 db.SaveChanges();
                 ENTITIES.Partner objPartner = db.Partners.Where(x => x.partner_name == input.partnername_add).First();
                 partner_id_item = objPartner.partner_id;
             }
             else //old partner
             {
                 partner_id_item = input.partner_id;
             }
             //add to MOUPartner via each partner of MOU
             db.MOUPartners.Add(new ENTITIES.MOUPartner
             {
                 mou_id              = mou_id,
                 partner_id          = partner_id_item,
                 mou_start_date      = DateTime.ParseExact(input.sign_date_mou_add, "dd/MM/yyyy", CultureInfo.InvariantCulture),
                 contact_point_name  = input.represent_add,
                 contact_point_email = input.email_add,
                 contact_point_phone = input.phone_add
             });
             //PartnerScope and MOUPartnerScope
             foreach (int tokenScope in input.coop_scope_add.ToList())
             {
                 PartnerScope objPS            = db.PartnerScopes.Where(x => x.partner_id == partner_id_item && x.scope_id == tokenScope).FirstOrDefault();
                 int          partner_scope_id = 0;
                 if (objPS == null)
                 {
                     db.PartnerScopes.Add(new PartnerScope
                     {
                         partner_id      = partner_id_item,
                         scope_id        = tokenScope,
                         reference_count = 0
                     });
                     //checkpoint 3
                     db.SaveChanges();
                     PartnerScope newObjPS = db.PartnerScopes.Where(x => x.partner_id == partner_id_item && x.scope_id == tokenScope).FirstOrDefault();
                     partner_scope_id = newObjPS.partner_scope_id;
                 }
                 else
                 {
                     objPS.reference_count += 1;
                     db.Entry(objPS).State  = EntityState.Modified;
                     partner_scope_id       = objPS.partner_scope_id;
                 }
                 db.MOUPartnerScopes.Add(new MOUPartnerScope
                 {
                     partner_scope_id = partner_scope_id,
                     mou_id           = mou_id
                 });
             }
             //checkpoint 4
             db.SaveChanges();
             //MOUPartnerSpe
             MOUPartner objMOUPartner = db.MOUPartners.Where(x => (x.mou_id == mou_id && x.partner_id == partner_id_item)).First();
             foreach (int tokenSpe in input.specialization_add.ToList())
             {
                 db.MOUPartnerSpecializations.Add(new MOUPartnerSpecialization
                 {
                     mou_partner_id    = objMOUPartner.mou_partner_id,
                     specialization_id = tokenSpe,
                 });
             }
             db.SaveChanges();
             transaction.Commit();
         }
         catch (Exception ex)
         {
             transaction.Rollback();
             throw ex;
         }
     }
 }