Example #1
0
        public async Task <ResultModel <Dictionary <string, object> > > Create(Dictionary <string, object> model)
        {
            try
            {
                IEnumerable <AddedColumn> addedColumns = await _addedColumn.GetAll();

                Contact entity      = MapToEntity(model, addedColumns);
                var     checkunique = await _contact.GetAll(t => t.Name == entity.Name);

                if (checkunique.Any())
                {
                    return(ResultModel <Dictionary <string, object> > .GetErrorResult(new List <ResultErrorModel> {
                        new ResultErrorModel(ResultErrorTypeEnum.UniqueFieldError, new string[] { "Contact Name" })
                    }));
                }
                entity = await _contact.Add(entity);

                await _contact.Commit();

                model = MapToModel(entity);
                return(ResultModel <Dictionary <string, object> > .GetSuccessResult(model));
            }
            catch (Exception e)
            {
                await _contact.Abort();

                ResultErrorModel error = new ResultErrorModel(e);
                return(ResultModel <Dictionary <string, object> > .GetExceptionResult(error));
            }
        }
Example #2
0
        public async Task <ResultModel <Dictionary <string, object> > > Update(Dictionary <string, object> model)
        {
            try
            {
                Contact entity = await _contact.GetById(int.Parse(model["ID"].ToString()));

                if (entity == null)
                {
                    return(ResultModel <Dictionary <string, object> > .GetErrorResult(new ResultErrorModel(ResultErrorTypeEnum.NotFoundError)));
                }

                IEnumerable <AddedColumn> addedColumns = await _addedColumn.GetAll();

                entity = MapToEntity(model, entity, addedColumns);
                var checkunique = await _contact.GetAll(t => t.Name == entity.Name && t.ID != entity.ID);

                if (checkunique.Any())
                {
                    return(ResultModel <Dictionary <string, object> > .GetErrorResult(new List <ResultErrorModel> {
                        new ResultErrorModel(ResultErrorTypeEnum.UniqueFieldError, new string[] { "Contact Name" })
                    }));
                }
                await _contact.Update(entity);

                await _contact.Commit();

                //Dictionary<string, object> data = MapToModel(entity);
                return(ResultModel <Dictionary <string, object> > .GetSuccessResult(model));
            }
            catch (Exception e)
            {
                ResultErrorModel error = new ResultErrorModel(e);
                return(ResultModel <Dictionary <string, object> > .GetExceptionResult(error));
            }
        }
Example #3
0
        public async Task <ResultModel <List <Dictionary <string, object> > > > GetAll(PaginationInfo paginationInfo)
        {
            try
            {
                IEnumerable <Contact> entities = await _contact.GetAll(paginationInfo);

                List <Dictionary <string, object> > data = (from entity in entities.AsParallel().AsOrdered() select MapToModel(entity)).ToList();
                return(ResultModel <List <Dictionary <string, object> > > .GetSuccessResult(data));
            }
            catch (Exception e)
            {
                ResultErrorModel error = new ResultErrorModel(e);
                return(ResultModel <List <Dictionary <string, object> > > .GetExceptionResult(error));
            }
        }
Example #4
0
        public async Task <ResultModel <object> > Delete(int Id)
        {
            try
            {
                await _contact.Remove(Id);

                await _contact.Commit();

                return(ResultModel <object> .GetSuccessResult());
            }
            catch (Exception e)
            {
                await _contact.Abort();

                ResultErrorModel error = new ResultErrorModel(e);
                return(ResultModel <object> .GetExceptionResult(error));
            }
        }
Example #5
0
        public async Task <ResultModel <Dictionary <string, object> > > GetById(int Id)
        {
            try
            {
                Contact entity = await _contact.GetById(Id);

                if (entity != null)
                {
                    Dictionary <string, object> data = MapToModel(entity);
                    return(ResultModel <Dictionary <string, object> > .GetSuccessResult(data));
                }
                return(ResultModel <Dictionary <string, object> > .GetFailureResult(new List <ResultErrorModel>() { new ResultErrorModel(ResultErrorTypeEnum.NotFoundError) }));
            }
            catch (Exception e)
            {
                ResultErrorModel error = new ResultErrorModel(e);
                return(ResultModel <Dictionary <string, object> > .GetExceptionResult(error));
            }
        }
Example #6
0
        public async Task <ResultModel <List <Dictionary <string, object> > > > Filter(List <ColumnFilterInfo> filters, PaginationInfo paginationInfo)
        {
            try
            {
                if (filters == null || !filters.Any())
                {
                    return(await GetAll(paginationInfo));
                }
                IEnumerable <Contact> entities = await _contact.GetFiltered(filters, paginationInfo);

                List <Dictionary <string, object> > data = (from entity in entities.AsParallel().AsOrdered() select MapToModel(entity)).ToList();
                return(ResultModel <List <Dictionary <string, object> > > .GetSuccessResult(data));
            }
            catch (Exception e)
            {
                ResultErrorModel error = new ResultErrorModel(e);
                return(ResultModel <List <Dictionary <string, object> > > .GetExceptionResult(error));
            }
        }
Example #7
0
        public async Task <ResultModel <AddedColumnModel> > Create(AddedColumnCreateModel model)
        {
            try
            {
                AddedColumn entity = MapToEntity(model);
                entity = await _addedColumn.Add(entity);

                await _addedColumn.Commit();

                AddedColumnModel returnModel = MapToModel(entity);
                return(ResultModel <AddedColumnModel> .GetSuccessResult(returnModel));
            }
            catch (Exception e)
            {
                await _addedColumn.Abort();

                ResultErrorModel error = new ResultErrorModel(e);
                return(ResultModel <AddedColumnModel> .GetExceptionResult(error));
            }
        }