Example #1
0
        public async Task <JsonResult> SaveUser(co_contact data)
        {
            string currUser = CurrentUser.User.ct_key.ToString();
            Guid   recID    = new Guid();

            try
            {
                var gID    = Guid.Parse(currUser);
                var updata = await db.co_contact.Where(w => w.ct_key == gID).FirstOrDefaultAsync();

                var Email = data.ct_email + updata.ct_email.Substring(updata.ct_email.IndexOf("@"));

                var existEmail = await db.co_contact.Where(w => w.ct_key != gID &&
                                                           w.ct_email.ToLower().Trim() == Email.ToLower().Trim()).FirstOrDefaultAsync();

                if (existEmail != null)
                {
                    return(Json(new
                    {
                        status = "error",
                        msg = "This email is already exist"
                    }, JsonRequestBehavior.AllowGet));
                }

                updata.ct_change_date = DateTime.Now;
                updata.ct_change_user = currUser;
                updata.ct_email       = Email;
                updata.ct_fax         = data.ct_fax;
                updata.ct_first_name  = data.ct_first_name;
                updata.ct_last_name   = data.ct_last_name;
                updata.ct_phone       = data.ct_phone;

                db.Entry(updata).State = EntityState.Modified;
                await db.SaveChangesAsync();

                recID = updata.ct_key;

                return(Json(new
                {
                    status = "Done"
                }, JsonRequestBehavior.AllowGet));
            }
            catch (Exception er)
            {
                return(Json(new
                {
                    status = "error",
                    msg = er.Message
                }, JsonRequestBehavior.AllowGet));
            }
        }
Example #2
0
        // GET: SystemUsers/Create
        public async Task <PartialViewResult> Create(string id)
        {
            ViewBag.OrgName   = "";
            ViewBag.OrgDomain = "";
            ViewBag.Perm      = "";
            if (!String.IsNullOrEmpty(id))
            {
                ViewBag.CID = id;
                var user = await db.co_contact.Where(w => w.ct_key.ToString() == id).FirstOrDefaultAsync();

                if (user == null)
                {
                    throw new Exception("User Not Fount");
                }
                var org = await db.contact_x_organization.Where(w => w.cxo_ct_key.ToString() == id).FirstOrDefaultAsync();

                if (org != null)
                {
                    ViewBag.OrgName   = org.co_organization.org_legal_name;
                    ViewBag.OrgDomain = org.co_organization.org_domain;
                }
                var Perm = await db.co_permission.Where(w => w.per_ct_key.ToString() == id).FirstOrDefaultAsync();

                if (Perm != null)
                {
                    ViewBag.Perm = Perm.per_type;
                }
                return(PartialView(user));
            }
            else
            {
                co_contact model = new co_contact();

                return(PartialView(model));
            }
        }
Example #3
0
        public async Task <JsonResult> SaveUser(co_contact data, bool IsActive, string ConfirmPassword,
                                                string upID, string OrgName, string OrgDomain, string Permission)
        {
            string currUser = CurrentUser.User.ct_key.ToString();
            Guid   recID    = new Guid();

            try
            {
                if (data.ct_password != ConfirmPassword)
                {
                    throw new Exception("Password Must be Matching.");
                }

                if (String.IsNullOrWhiteSpace(upID))
                {
                    var existingUser = await db.co_contact.Where(w =>
                                                                 w.ct_email.ToLower().Trim() == data.ct_email.ToLower().Trim()).FirstOrDefaultAsync();

                    if (existingUser != null)
                    {
                        return(Json(new
                        {
                            status = "error",
                            msg = "This email is already registered"
                        }, JsonRequestBehavior.AllowGet));
                    }
                    data.ct_active   = IsActive ? (byte)1 : (byte)0;
                    data.ct_password = data.ct_password.GetEncryptedString();
                    data.ct_add_date = DateTime.Now;
                    data.ct_add_user = currUser;
                    data.ct_key      = Guid.NewGuid();
                    db.co_contact.Add(data);
                    await db.SaveChangesAsync();

                    recID = data.ct_key;
                }
                else
                {
                    var gID    = Guid.Parse(upID);
                    var updata = await db.co_contact.Where(w => w.ct_key == gID).FirstOrDefaultAsync();

                    if (updata.ct_email != data.ct_email)
                    {
                        var existingUser = await db.co_contact.Where(w =>
                                                                     w.ct_email.ToLower().Trim() == data.ct_email.ToLower().Trim()).FirstOrDefaultAsync();

                        if (existingUser != null)
                        {
                            return(Json(new
                            {
                                status = "error",
                                msg = "This email is already registered"
                            }, JsonRequestBehavior.AllowGet));
                        }
                    }
                    updata.ct_active       = data.ct_active;
                    updata.ct_change_date  = DateTime.Now;
                    updata.ct_change_user  = currUser;
                    updata.ct_email        = data.ct_email;
                    updata.ct_fax          = data.ct_fax;
                    updata.ct_first_name   = data.ct_first_name;
                    updata.ct_last_name    = data.ct_last_name;
                    updata.ct_phone        = data.ct_phone;
                    updata.ct_active       = IsActive ? (byte)1 : (byte)0;
                    db.Entry(updata).State = EntityState.Modified;
                    await db.SaveChangesAsync();

                    recID = updata.ct_key;
                }
                if (!String.IsNullOrEmpty(OrgName) && !String.IsNullOrEmpty(OrgDomain) && String.IsNullOrWhiteSpace(upID))
                {
                    co_organization org = await db.co_organization.Where(w => w.org_legal_name.ToLower().Trim() == OrgName.ToLower().Trim() &&
                                                                         w.org_domain.ToLower().Trim() == OrgDomain.ToLower().Trim()).FirstOrDefaultAsync();

                    Guid orgKey = new Guid();
                    if (org == null)
                    {
                        var newOrg = new co_organization()
                        {
                            org_key        = Guid.NewGuid(),
                            org_add_date   = DateTime.Now,
                            org_add_user   = currUser,
                            org_domain     = OrgDomain,
                            org_legal_name = OrgName
                        };
                        db.co_organization.Add(newOrg);
                        await db.SaveChangesAsync();

                        orgKey = newOrg.org_key;
                    }
                    else
                    {
                        orgKey = org.org_key;
                    }

                    var con_org = await db.contact_x_organization.Where(w => w.cxo_org_key == orgKey).FirstOrDefaultAsync();

                    if (con_org == null)
                    {
                        var newOrgCon = new contact_x_organization()
                        {
                            cxo_key      = Guid.NewGuid(),
                            cxo_add_date = DateTime.Now,
                            cxo_add_user = currUser,
                            cxo_ct_key   = recID,
                            cxo_org_key  = orgKey
                        };
                        db.contact_x_organization.Add(newOrgCon);
                        await db.SaveChangesAsync();
                    }
                }

                var perm = await db.co_permission.Where(w => w.per_ct_key == recID).FirstOrDefaultAsync();

                if (perm != null && Permission != perm.per_type)
                {
                    if (String.IsNullOrWhiteSpace(Permission))
                    {
                        db.co_permission.Remove(perm);
                        await db.SaveChangesAsync();
                    }
                    else
                    {
                        perm.per_type        = Permission;
                        perm.per_change_date = DateTime.Now;
                        perm.per_change_user = currUser;
                        db.Entry(perm).State = EntityState.Modified;
                        await db.SaveChangesAsync();
                    }
                }
                else if (perm == null)
                {
                    db.co_permission.Add(new co_permission
                    {
                        per_ct_key   = recID,
                        per_key      = Guid.NewGuid(),
                        per_add_date = DateTime.Now,
                        per_add_user = currUser,
                        per_type     = Permission
                    });
                    await db.SaveChangesAsync();
                }

                return(Json(new
                {
                    status = "Done"
                }, JsonRequestBehavior.AllowGet));
            }
            catch (Exception er)
            {
                return(Json(new
                {
                    status = "error",
                    msg = er.Message
                }, JsonRequestBehavior.AllowGet));
            }
        }