Exemple #1
0
        public async Task <MisSaveResponse> DeleteMisArtifactData([FromBody] SearchMisReqGet request)
        {
            var response = new MisSaveResponse();

            try
            {
                if (request != null)
                {
                    response = await _MISRepository.DeleteMisArtifactData(request);

                    if (response == null)
                    {
                        response.Response.Status       = "Failure";
                        response.Response.ErrorMessage = "An error.";
                    }
                }
                else
                {
                    response.Response.Status       = "Failure";
                    response.Response.ErrorMessage = "Request details can not be blank.";
                }
            }
            catch (Exception ex)
            {
                response.Response.Status       = "Failure";
                response.Response.ErrorMessage = "An error occurs " + ex.Message.ToString();
            }
            return(response);
        }
Exemple #2
0
        public async Task <MisSaveResponse> DeleteMisArtifactData(SearchMisReqGet request)
        {
            mMISMapping     mMis     = new mMISMapping();
            List <string>   Roles    = new List <string>();
            MisSaveResponse response = new MisSaveResponse();

            try
            {
                mMis = _MongoContext.mMISMapping.AsQueryable().Where(x => x.ItemType == request.TypeName && x.Item == request.Item && x.UserGroups.Contains(request.RoleName)).FirstOrDefault();

                if (mMis != null)
                {
                    Roles.AddRange(mMis.UserGroups);
                    mMis.UserGroups.Clear();
                    Roles.ForEach(x => { if (String.Compare(x, request.RoleName, true) != 0)
                                         {
                                             mMis.UserGroups.Add(x);
                                         }
                                  });
                }
                await _MongoContext.mMISMapping.UpdateOneAsync(Builders <mMISMapping> .Filter.Eq("_Id", mMis._Id),
                                                               Builders <mMISMapping> .Update.Set("UserGroups", mMis.UserGroups));

                response.Response.Status        = "Success";
                response.Response.StatusMessage = "Deleted Successfully";
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                response.Response.Status = "Failure";
            }
            return(response);
        }
Exemple #3
0
        public async Task <MisSaveResponse> SaveMisData(SearchMisReqGet request, string ticket)
        {
            MisSaveResponse misMappingRes = new MisSaveResponse();

            misMappingRes = await serviceProxy.PostData(_configuration.GetValue <string>("ServiceMIS:SaveMisData"), request, typeof(MisSaveResponse), ticket);

            return(misMappingRes);
        }
Exemple #4
0
        public async Task <MisSaveResponse> SaveMisData(SearchMisReqGet request)
        {
            mMISMapping     mMis     = new mMISMapping();
            mMISMapping     mMisNew  = new mMISMapping();
            MisSaveResponse response = new MisSaveResponse();

            try
            {
                mMis = _MongoContext.mMISMapping.AsQueryable().Where(x => x.ItemType == request.TypeName && x.Item.ToLower() == request.Item.ToLower().Trim()).FirstOrDefault();
                if (mMis != null)
                {
                    mMis.UserGroups.Add(request.RoleName);
                    await _MongoContext.mMISMapping.UpdateOneAsync(Builders <mMISMapping> .Filter.Eq("_Id", mMis._Id),
                                                                   Builders <mMISMapping> .Update.Set("UserGroups", mMis.UserGroups));

                    response.Id                     = mMis._Id;
                    response.TypeName               = mMis.ItemType;
                    response.Item                   = mMis.Item;
                    response.ItemUrl                = mMis.ItemUrl;
                    response.Users                  = mMis.UserGroups;
                    response.ItemSeq                = mMis.ItemSeq;
                    response.Response.Status        = "Success";
                    response.Response.StatusMessage = "Successfully Updated Data";
                }
                if (mMis == null)
                {
                    var Sequence = _MongoContext.mMISMapping.AsQueryable().Max(x => x.ItemSeq);
                    mMisNew.ItemType = request.TypeName;
                    mMisNew.Item     = request.Item.Trim();
                    mMisNew.ItemSeq  = (Sequence + 1);
                    mMisNew.UserGroups.Add(request.RoleName);
                    await _MongoContext.mMISMapping.InsertOneAsync(mMisNew);

                    response.Id                     = mMisNew._Id;
                    response.TypeName               = mMisNew.ItemType;
                    response.Item                   = mMisNew.Item;
                    response.ItemUrl                = mMisNew.ItemUrl;
                    response.Users                  = mMisNew.UserGroups;
                    response.ItemSeq                = mMisNew.ItemSeq;
                    response.Response.Status        = "Success";
                    response.Response.StatusMessage = "Successfully Inserted Data";
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                response.Response.Status = "Failure";
            }
            return(response);
        }
        public IActionResult DeleteMisArtifactData(MisArtifactsViewModel model)
        {
            MisSaveResponse response = new MisSaveResponse();
            SearchMisReqGet request  = new SearchMisReqGet();

            request.TypeName = model.TypeName;
            request.Item     = model.Item;
            request.RoleName = model.RoleName;
            try
            {
                response = objMISProviders.DeleteMisArtifactData(request, token).Result;
                return(RedirectToAction("SearchMisArtifactsList"));
            }
            catch (Exception ex)
            {
                response.Response.Status        = "Error";
                response.Response.StatusMessage = "Error occurred while deleting record";
                return(Json(new { responseText = response.Response.StatusMessage, status = response.Response.Status }));
            }
        }
        public IActionResult SearchMisArtifacts(SearchMisReqGet request, int draw, int start, int length)
        {
            List <MisArtifactsViewModel> modelList = new List <MisArtifactsViewModel>();
            MisArtifactsViewModel        artifacts;

            if (length == 0)
            {
                length = 10;
            }
            request.TypeName = request.TypeName == "Select" ? null : request.TypeName;
            request.RoleName = request.RoleName == "Select" ? null : request.RoleName;
            var result = objMISProviders.SearchMisData(request, token).Result;

            foreach (var m in result.MisResults)
            {
                foreach (var n in m.Groups)
                {
                    artifacts = new MisArtifactsViewModel();
                    artifacts.TypeNameResponse = m.Type;
                    artifacts.ItemResponse     = m.Item;
                    artifacts.Id = m._Id.ToString();
                    artifacts.RoleNameResponse = n;
                    modelList.Add(artifacts);
                }
            }
            if (!String.IsNullOrEmpty(request.RoleName))
            {
                modelList = modelList.Where(x => x.RoleNameResponse == request.RoleName).ToList();
            }
            var response = modelList.Skip(start).Take(length);

            return(Json(new
            {
                draw = draw,
                recordsTotal = modelList.Count,
                recordsFiltered = modelList.Count,
                data = response
            }));
        }
        public IActionResult SaveArtifactsData(MisArtifactsViewModel model)
        {
            MisSaveResponse response = new MisSaveResponse();
            SearchMisReqGet request  = new SearchMisReqGet();

            request.TypeName = model.TypeName;
            request.Item     = model.Item;
            request.RoleName = model.RoleName;
            var retValue = objMISProviders.SearchMisData(request, token).Result;

            if (retValue != null && retValue.MisResults.Any())
            {
                response.Response.Status        = "Alert";
                response.Response.StatusMessage = "Artifacts Data to be Added already exist.";
                return(Json(new { responseText = response.Response.StatusMessage, status = response.Response.Status }));
            }
            else
            {
                response = objMISProviders.SaveMisData(request, token).Result;
                return(RedirectToAction("SearchMisArtifactsList"));
            }
        }
Exemple #8
0
        public async Task <MisSearchGetResList> SearchMisData(SearchMisReqGet request)
        {
            MisSearchGetResList response = new MisSearchGetResList();

            try
            {
                response.MisResults = _MongoContext.mMISMapping.AsQueryable().Select(x => new MisSearchGetRes
                {
                    Type    = x.ItemType,
                    Item    = x.Item,
                    ItemSeq = x.ItemSeq,
                    _Id     = x._Id,
                    Groups  = x.UserGroups
                }).ToList();

                if (!string.IsNullOrEmpty(request.TypeName))
                {
                    response.MisResults = response.MisResults.Where(x => x.Type == request.TypeName).ToList();
                }
                if (!string.IsNullOrEmpty(request.Item))
                {
                    response.MisResults = response.MisResults.Where(x => x.Item.ToLower() == request.Item.ToLower().Trim()).ToList();
                }
                if (!string.IsNullOrEmpty(request.RoleName))
                {
                    response.MisResults = response.MisResults.Where(x => x.Groups.Contains(request.RoleName)).ToList();
                }

                response.ResponseStatus.Status = "Success";
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                response.ResponseStatus.Status = "Failure";
            }
            return(response);
        }