コード例 #1
0
ファイル: EmployeeManager.cs プロジェクト: vigneshc91/Billing
        public bool AddEmployee(Admin admin, Employee employee)
        {
            if (employee == null) throw new Exception(ErrorConstants.REQUIRED_FIELD_EMPTY);
            if (admin == null || admin.type != (int)BillingEnums.USER_TYPE.ADMIN) throw new Exception(ErrorConstants.NO_PREVILAGE);

            try
            {
                var elasticClient = GetElasticClient();

                var employeeExist = GetEmployeeById(admin, employee.employeeid);
                if (employeeExist != null) throw new Exception(ErrorConstants.EMPLOYEE_WITH_GIVEN_ID_ALREADY_EXIST);

                var response = elasticClient.Index<Employee>(employee, i => i
                 .Index(ElasticMappingConstants.INDEX_NAME)
                 .Type(ElasticMappingConstants.TYPE_EMPLOYEE)
                );

                return response.RequestInformation.Success;
            }
            catch (Exception e)
            {

                throw e;
            }
        }
コード例 #2
0
ファイル: ProductManager.cs プロジェクト: vigneshc91/Billing
        public bool AddProduct(Admin admin, Product product)
        {
            if (product == null) throw new Exception(ErrorConstants.REQUIRED_FIELD_EMPTY);
            if (admin == null || admin.type != (short)BillingEnums.USER_TYPE.ADMIN) throw new Exception(ErrorConstants.NO_PREVILAGE);

            try
            {
                var productExist = GetProductById(admin, product.productid);

                if (productExist != null)
                    throw new Exception(ErrorConstants.PRODUCT_WITH_GIVEN_ID_ALREADY_EXIST);

                var elasticClient = GetElasticClient();

                var response = elasticClient.Index<Product>(product, i => i
                .Index(ElasticMappingConstants.INDEX_NAME)
                .Type(ElasticMappingConstants.TYPE_PRODUCT)
                );

                return response.RequestInformation.Success;
            }
            catch (Exception e)
            {

                throw e;
            }
        }
コード例 #3
0
ファイル: ProductManager.cs プロジェクト: vigneshc91/Billing
        public Product GetProductById(Admin admin, string id)
        {
            if (String.IsNullOrWhiteSpace(id)) throw new Exception(ErrorConstants.REQUIRED_FIELD_EMPTY);
            if (admin == null || admin.type != (short)BillingEnums.USER_TYPE.ADMIN) throw new Exception(ErrorConstants.NO_PREVILAGE);

            try
            {
                var elasticClient = GetElasticClient();

                var response = elasticClient.Search<Product>(g => g
                .Index(ElasticMappingConstants.INDEX_NAME)
                .Type(ElasticMappingConstants.TYPE_PRODUCT)
                .Filter(f => f.Term(ConstProduct.ID, id))
                .Size(1));

                Product product = null;

                if(response.Total > 0)
                    foreach (var item in response.Hits)
                        product = item.Source;
                    

                return product;

            }
            catch (Exception e)
            {

                throw e;
            }

        }
コード例 #4
0
ファイル: EmployeeManager.cs プロジェクト: vigneshc91/Billing
        public Employee GetEmployeeById(Admin admin, string employeeid)
        {
            if (String.IsNullOrWhiteSpace(employeeid)) throw new Exception(ErrorConstants.REQUIRED_FIELD_EMPTY);
            if (admin == null || admin.type != (int)BillingEnums.USER_TYPE.ADMIN) throw new Exception(ErrorConstants.NO_PREVILAGE);

            try
            {
                var elasticClient = GetElasticClient();

                var response = elasticClient.Search<Employee>(s => s
                .Index(ElasticMappingConstants.INDEX_NAME)
                .Type(ElasticMappingConstants.TYPE_EMPLOYEE)
                .Filter(f => f.Term(ConstEmployee.ID, employeeid))
                .Size(1));

                Employee retEmployee = null;

                if (response.Total > 0)
                    foreach (var item in response.Hits)
                        retEmployee = item.Source;

                return retEmployee;
            }
            catch (Exception e)
            {

                throw e;
            }
        }
コード例 #5
0
ファイル: UserManager.cs プロジェクト: vigneshc91/Billing
        public bool AddUser(Admin admin, User user)
        {
            if (user == null) throw new Exception(ErrorConstants.REQUIRED_FIELD_EMPTY);
            if (admin == null || admin.type != (int)BillingEnums.USER_TYPE.ADMIN) throw new Exception(ErrorConstants.NO_PREVILAGE);

            try
            {
                var elasticClient = GetElasticClient();

                var userExist = GetUserById(admin, user.userid);
                if (userExist != null) throw new Exception(ErrorConstants.USER_WITH_GIVEN_ID_ALREADY_EXIST);

                var response = elasticClient.Index<User>(user, i => i
                 .Index(ElasticMappingConstants.INDEX_NAME)
                 .Type(ElasticMappingConstants.TYPE_USER)
                );

                return response.RequestInformation.Success;
            }
            catch (Exception e)
            {

                throw e;
            }
        }
コード例 #6
0
ファイル: AdminManager.cs プロジェクト: vigneshc91/Billing
        public bool CreateAdmin(Admin admin, string userName)
        {
            if (String.IsNullOrWhiteSpace(userName)) throw new Exception(ErrorConstants.REQUIRED_FIELD_EMPTY);
            if (admin == null || admin.type != (int)BillingEnums.USER_TYPE.SUPER_ADMIN) throw new Exception(ErrorConstants.NO_PREVILAGE);

            var newAdmin = new Admin()
            {
                id = Guid.NewGuid(),
                username = userName,
                type = (int)BillingEnums.USER_TYPE.ADMIN,
                created_at = DateTime.UtcNow
            };

            try
            {
                var elasticClient = GetElasticClient();

                var userNameFilter = new TermFilter()
                {
                    Field = ConstAdmin.USER_NAME,
                    Value = userName
                };

                var adminList = elasticClient.Search<Admin>(s => s
                .Index(ElasticMappingConstants.INDEX_NAME)
                .Type(ElasticMappingConstants.TYPE_ADMIN)
                .Filter(userNameFilter)
                );

                if(adminList.Total > 0)
                {
                    throw new Exception(ErrorConstants.ADMIN_USERNAME_ALREADY_TAKEN);
                }

                var response = elasticClient.Index<Admin>(newAdmin, i => i
                .Index(ElasticMappingConstants.INDEX_NAME)
                .Type(ElasticMappingConstants.TYPE_ADMIN)
                );

                return response.Created;

            }
            catch (Exception e)
            {
                
                Console.Error.WriteLine(e.GetBaseException().Message);
                throw e;
            }
        }
コード例 #7
0
ファイル: AdminManager.cs プロジェクト: vigneshc91/Billing
        public Admin LoginAdmin(string userName, string password)
        {
            if (String.IsNullOrWhiteSpace(userName) || String.IsNullOrWhiteSpace(password))
                throw new Exception(ErrorConstants.REQUIRED_FIELD_EMPTY);

            try
            {
                var elasticClient = GetElasticClient();

                var userNameFilter = new TermFilter() {
                    Field = ConstAdmin.USER_NAME,
                    Value = userName
                };

                var loginFilters = new List<FilterContainer>();
                loginFilters.Add(userNameFilter);

                var loginFilter = new AndFilter();
                loginFilter.Filters = loginFilters;

                var loginResponse = elasticClient.Search<Admin>(s => s
                .Index(ElasticMappingConstants.INDEX_NAME)
                .Type(ElasticMappingConstants.TYPE_ADMIN)
                .Filter(loginFilter)
                .Size(1));

                var admin = new Admin();

                if (loginResponse.Total > 0)
                {
                    foreach (IHit<Admin> hit in loginResponse.Hits)
                    {
                        admin = hit.Source;
                    }
                    if (!PasswordHash.ValidatePassword(password, admin.password, admin.salt))
                        throw new Exception(ErrorConstants.WRONG_PASSWORD);
                    return admin;
                }
                else
                    return null;
                

            }
            catch (Exception e)
            {
                Console.Error.WriteLine(e.GetBaseException().Message);
                return null;
            }
        }
コード例 #8
0
        public void AddSuperAdmin()
        {
            var elasticClient = GetElasticClient();

            var termFilter = new TermFilter()
            {
                Field = ConstAdmin.TYPE,
                Value = (short)BillingEnums.USER_TYPE.SUPER_ADMIN
            };

            try
            {
                var response = elasticClient.Search<Admin>(a => a
                                .Index(ElasticMappingConstants.INDEX_NAME)
                                .Type(ElasticMappingConstants.TYPE_ADMIN)
                                .Filter(termFilter)
                                .Take(1));

                if (response.Total == 0)
                {
                    var salt = PasswordHash.GenerateSalt();
                    var admin = new Admin()
                    {
                        id = Guid.NewGuid(),
                        username = AppConstants.SUPER_ADMIN_USER_NAME,
                        salt = salt,
                        password = PasswordHash.CreateHash(AppConstants.SUPER_ADMIN_PASSWORD, salt),
                        type = (int)BillingEnums.USER_TYPE.SUPER_ADMIN,
                        created_at = DateTime.UtcNow
                    };

                    var create = elasticClient.Index<Admin>(admin, i => i
                                    .Index(ElasticMappingConstants.INDEX_NAME)
                                    .Type(ElasticMappingConstants.TYPE_ADMIN));
                    
                }
            }
            catch (Exception e)
            {

                Console.Error.WriteLine(e.GetBaseException().Message);
            }

            
        }
コード例 #9
0
ファイル: SalesManager.cs プロジェクト: vigneshc91/Billing
        public bool AddSales(Admin admin, Sales sales, List<SalesInfo> salesInfo, bool stock)
        {
            if (sales == null || salesInfo == null) throw new Exception(ErrorConstants.REQUIRED_FIELD_EMPTY);

            if (admin == null || admin.type != (int)BillingEnums.USER_TYPE.ADMIN) throw new Exception(ErrorConstants.NO_PREVILAGE);

            try
            {
                
                var elasticClient = GetElasticClient();

                var salesResponse = elasticClient.Index<Sales>(sales, i => i
                .Index(ElasticMappingConstants.INDEX_NAME)
                .Type(ElasticMappingConstants.TYPE_SALES)
                );

                var insertDescriptor = new BulkDescriptor();

                foreach (var item in salesInfo)
                {
                    item.salesid = sales.salesid;
                    
                    insertDescriptor.Index<SalesInfo>(i => i
                    .Index(ElasticMappingConstants.INDEX_NAME)
                    .Type(ElasticMappingConstants.TYPE_SALES_INFO)
                    .Document(item)
                    );
                }


                var bulkResponse = elasticClient.Bulk(insertDescriptor);

                return salesResponse.RequestInformation.Success && bulkResponse.RequestInformation.Success;

            }
            catch (Exception e)
            {

                throw e;
            }

        }
コード例 #10
0
ファイル: ProductManager.cs プロジェクト: vigneshc91/Billing
        public bool UpdateProduct(Admin admin, Product product)
        {
            if (product == null) throw new Exception(ErrorConstants.REQUIRED_FIELD_EMPTY);
            if (admin == null || admin.type != (short)BillingEnums.USER_TYPE.ADMIN) throw new Exception(ErrorConstants.NO_PREVILAGE);

            try
            {
                var productElasticId = GetProductId(product.productid);
                if(String.IsNullOrWhiteSpace(productElasticId))
                {
                    throw new Exception(ErrorConstants.PRODUCT_NOT_FOUND);
                }

                var productUpdate = new Dictionary<string, object>();
                if (!String.IsNullOrWhiteSpace(product.productname))
                    productUpdate[ConstProduct.PRODUCT_NAME] = product.productname;
                if (product.price>0)
                    productUpdate[ConstProduct.PRICE] = product.price;
                if (product.quantity>0)
                    productUpdate[ConstProduct.QUANTITY] = product.quantity;
                if (product.unit>0)
                    productUpdate[ConstProduct.UNIT] = product.unit;

                var elasticClient = GetElasticClient();

                var response = elasticClient.Update<Product, object>(u => u
                .Index(ElasticMappingConstants.INDEX_NAME)
                .Type(ElasticMappingConstants.TYPE_PRODUCT)
                .Id(productElasticId)
                .Doc(productUpdate)
                );

                return response.RequestInformation.Success;
            }
            catch (Exception e)
            {

                throw e;
            }

        }
コード例 #11
0
ファイル: EmployeeManager.cs プロジェクト: vigneshc91/Billing
        public List<Employee> GetEmployeeList(Admin admin, int start, int size)
        {
            if (admin == null || admin.type != (int)BillingEnums.USER_TYPE.ADMIN) throw new Exception(ErrorConstants.NO_PREVILAGE);

            try
            {
                var elasticClient = GetElasticClient();

                var response = elasticClient.Search<Employee>(s => s
                .Index(ElasticMappingConstants.INDEX_NAME)
                .Type(ElasticMappingConstants.TYPE_EMPLOYEE)
                .Skip(start)
                .Take(size)
                );

                var employeeList = new List<Employee>();
                if (response.Total > 0)
                    foreach (var item in response.Hits)
                        employeeList.Add(item.Source);

                return employeeList;

            }
            catch (Exception e)
            {

                throw e;
            }
        }
コード例 #12
0
ファイル: AdminManager.cs プロジェクト: vigneshc91/Billing
        public List<Admin> GetAdminList(Admin admin)
        {
            if (admin == null || admin.type != (int)BillingEnums.USER_TYPE.SUPER_ADMIN) throw new Exception(ErrorConstants.NO_PREVILAGE);

            try
            {
                var elasticClient = GetElasticClient();

                var response = elasticClient.Search<Admin>(s => s
                .Index(ElasticMappingConstants.INDEX_NAME)
                .Type(ElasticMappingConstants.TYPE_ADMIN)
                .Filter(f => f.Term(ConstAdmin.TYPE, (int)BillingEnums.USER_TYPE.ADMIN))
                .SortAscending(a => a.username)
                .Size(int.MaxValue));

                if (!response.RequestInformation.Success)
                    throw new Exception(ErrorConstants.PROBLEM_OCCURES_ON_RETRIVING_ADMIN_LIST);

                var adminList = new List<Admin>();

                foreach (var hit in response.Hits)
                {
                    var resultAdmin = hit.Source;
                    resultAdmin.salt = null;
                    resultAdmin.password = null;
                    adminList.Add(resultAdmin);
                }

                return adminList;
            }
            catch (Exception e )
            {

                throw e;
            }
            
        }
コード例 #13
0
ファイル: AdminManager.cs プロジェクト: vigneshc91/Billing
        public bool DeleteAdmin(Admin admin, Guid adminId)
        {
            if (adminId == null) throw new Exception(ErrorConstants.REQUIRED_FIELD_EMPTY);
            if (admin == null || admin.type != (int)BillingEnums.USER_TYPE.SUPER_ADMIN) throw new Exception(ErrorConstants.NO_PREVILAGE);

            try
            {
                var deleteAdmin = GetAdminById(adminId);
                if (deleteAdmin == null)
                    throw new Exception(ErrorConstants.ADMIN_NOT_FOUND);

                var elasticClient = GetElasticClient();
                var response = elasticClient.Delete<Admin>(adminId.ToString(), d => d
                .Index(ElasticMappingConstants.INDEX_NAME)
                .Type(ElasticMappingConstants.TYPE_ADMIN));

                if (response.RequestInformation.Success)
                    return true;

                return false;
            }
            catch (Exception e)
            {

                throw e;
            }
        }
コード例 #14
0
ファイル: AdminManager.cs プロジェクト: vigneshc91/Billing
        public bool ChangePassword(Admin admin, string oldPassword, string newPassword)
        {
            if (String.IsNullOrWhiteSpace(oldPassword) || String.IsNullOrWhiteSpace(newPassword)) throw new Exception(ErrorConstants.REQUIRED_FIELD_EMPTY);
            if (admin == null) throw new Exception(ErrorConstants.NO_PREVILAGE);

            try
            {
                var updateAdmin = GetAdminById(admin.id);
                if (updateAdmin == null)
                    throw new Exception(ErrorConstants.ADMIN_NOT_FOUND);

                if (!PasswordHash.ValidatePassword(oldPassword, updateAdmin.password, updateAdmin.salt))
                    throw new Exception(ErrorConstants.WRONG_PASSWORD);

                var newPasswordHash = PasswordHash.CreateHash(newPassword, updateAdmin.salt);

                var elasticClient = GetElasticClient();
                var passwordDict = new Dictionary<string, object>();
                passwordDict[ConstAdmin.PASSWORD] = newPasswordHash;

                var response = elasticClient.Update<Admin, object>(u => u
                .Index(ElasticMappingConstants.INDEX_NAME)
                .Type(ElasticMappingConstants.TYPE_ADMIN)
                .Id(admin.id.ToString())
                .Doc(passwordDict));

                if (response.RequestInformation.Success)
                    return true;

                return false;
            }
            catch (Exception e)
            {

                throw e;
            }
        }
コード例 #15
0
ファイル: AdminManager.cs プロジェクト: vigneshc91/Billing
        public string GenerateAdminPassword(Admin admin, Guid userId)
        {
            if (userId == null) throw new Exception(ErrorConstants.REQUIRED_FIELD_EMPTY);
            if (admin == null || admin.type != (int)BillingEnums.USER_TYPE.SUPER_ADMIN) throw new Exception(ErrorConstants.NO_PREVILAGE);

            try
            {
                var updateAdmin = GetAdminById(userId);
                if (updateAdmin == null) throw new Exception(ErrorConstants.ADMIN_NOT_FOUND);

                var password = Guid.NewGuid().ToString().Replace("-", "").Substring(0, 10);
                updateAdmin.salt = PasswordHash.GenerateSalt();
                updateAdmin.password = PasswordHash.CreateHash(password, updateAdmin.salt);

                var adminUpdate = new Dictionary<string, object>();
                adminUpdate[ConstAdmin.SALT] = updateAdmin.salt;
                adminUpdate[ConstAdmin.PASSWORD] = updateAdmin.password;

                var elasticClient = GetElasticClient();

                var updateResponse = elasticClient.Update<Admin, object>(u => u
                .Index(ElasticMappingConstants.INDEX_NAME)
                .Type(ElasticMappingConstants.TYPE_ADMIN)
                .Id(updateAdmin.id.ToString())
                .Doc(adminUpdate));

                if (!updateResponse.RequestInformation.Success)
                    throw new Exception(ErrorConstants.PROBLEM_OCCURED_WHILE_GENERATING_PASSWORD);

                return password;

            }
            catch (Exception e)
            {

                throw e;
            }
        }
コード例 #16
0
ファイル: EmployeeManager.cs プロジェクト: vigneshc91/Billing
        public bool UpdateEmployee(Admin admin, Employee employee)
        {
            if (employee == null) throw new Exception(ErrorConstants.REQUIRED_FIELD_EMPTY);
            if (admin == null || admin.type != (int)BillingEnums.USER_TYPE.ADMIN) throw new Exception(ErrorConstants.NO_PREVILAGE);

            try
            {
                var employeeElasticId = GetEmployeeId(employee.employeeid);
                if (String.IsNullOrWhiteSpace(employeeElasticId)) throw new Exception(ErrorConstants.EMPLOYEE_NOT_FOUND);

                var employeeUpdate = new Dictionary<string, object>();

                if (!String.IsNullOrWhiteSpace(employee.name))
                    employeeUpdate[ConstEmployee.NAME] = employee.name;
                if (!String.IsNullOrWhiteSpace(employee.addr1))
                    employeeUpdate[ConstEmployee.ADDR_1] = employee.addr1;
                if (!String.IsNullOrWhiteSpace(employee.addr2))
                    employeeUpdate[ConstEmployee.ADDR_2] = employee.addr2;
                if (!String.IsNullOrWhiteSpace(employee.city))
                    employeeUpdate[ConstEmployee.CITY] = employee.city;
                if (!String.IsNullOrWhiteSpace(employee.district))
                    employeeUpdate[ConstEmployee.DISTRICT] = employee.district;
                if (!String.IsNullOrWhiteSpace(employee.state))
                    employeeUpdate[ConstEmployee.STATE] = employee.state;
                if (!String.IsNullOrWhiteSpace(employee.country))
                    employeeUpdate[ConstEmployee.COUNTRY] = employee.country;
                if (!String.IsNullOrWhiteSpace(employee.pincode))
                    employeeUpdate[ConstEmployee.PIN_CODE] = employee.pincode;
                if (!String.IsNullOrWhiteSpace(employee.phone))
                    employeeUpdate[ConstEmployee.PHONE] = employee.phone;
                if (!String.IsNullOrWhiteSpace(employee.email))
                    employeeUpdate[ConstEmployee.EMAIL] = employee.email;
                if (!String.IsNullOrWhiteSpace(employee.designation))
                    employeeUpdate[ConstEmployee.DESIGNATION] = employee.designation;
                var elasticClient = GetElasticClient();

                var response = elasticClient.Update<Employee, object>(u => u
                .Index(ElasticMappingConstants.INDEX_NAME)
                .Type(ElasticMappingConstants.TYPE_EMPLOYEE)
                .Id(employeeElasticId)
                .Doc(employeeUpdate)
                );

                return response.RequestInformation.Success;
            }
            catch (Exception e)
            {

                throw e;
            }
        }
コード例 #17
0
ファイル: EmployeeManager.cs プロジェクト: vigneshc91/Billing
        public List<Employee> GetEmployeesByName(Admin admin, string name, int start, int size)
        {
            if (String.IsNullOrWhiteSpace(name)) throw new Exception(ErrorConstants.REQUIRED_FIELD_EMPTY);
            if (admin == null || admin.type != (int)BillingEnums.USER_TYPE.ADMIN) throw new Exception(ErrorConstants.NO_PREVILAGE);

            try
            {
                var elasticClient = GetElasticClient();

                var response = elasticClient.Search<Employee>(s => s
                .Index(ElasticMappingConstants.INDEX_NAME)
                .Type(ElasticMappingConstants.TYPE_EMPLOYEE)
                .Query(q => q.Prefix(ConstEmployee.NAME, name))
                .Skip(start)
                .Take(size)
                );

                var employeeList = new List<Employee>();

                if (response.Total > 0)
                    foreach (var item in response.Hits)
                        employeeList.Add(item.Source);

                return employeeList;
            }
            catch (Exception e)
            {

                throw e;
            }
        }
コード例 #18
0
ファイル: UserManager.cs プロジェクト: vigneshc91/Billing
        public bool  UpdateUser(Admin admin, User user)
        {
            if (user == null) throw new Exception(ErrorConstants.REQUIRED_FIELD_EMPTY);
            if (admin == null || admin.type != (int)BillingEnums.USER_TYPE.ADMIN) throw new Exception(ErrorConstants.NO_PREVILAGE);

            try
            {
                var userElasticId = GetUserId(user.userid);
                if (String.IsNullOrWhiteSpace(userElasticId)) throw new Exception(ErrorConstants.USER_NOT_FOUND);

                var userUpdate = new Dictionary<string, object>();

                if (!String.IsNullOrWhiteSpace(user.name))
                    userUpdate[ConstUser.NAME] = user.name;
                if (!String.IsNullOrWhiteSpace(user.addr1))
                    userUpdate[ConstUser.ADDR_1] = user.addr1;
                if (!String.IsNullOrWhiteSpace(user.addr2))
                    userUpdate[ConstUser.ADDR_2] = user.addr2;
                if (!String.IsNullOrWhiteSpace(user.city))
                    userUpdate[ConstUser.CITY] = user.city;
                if (!String.IsNullOrWhiteSpace(user.district))
                    userUpdate[ConstUser.DISTRICT] = user.district;
                if (!String.IsNullOrWhiteSpace(user.state))
                    userUpdate[ConstUser.STATE] = user.state;
                if (!String.IsNullOrWhiteSpace(user.country))
                    userUpdate[ConstUser.COUNTRY] = user.country;
                if (!String.IsNullOrWhiteSpace(user.pincode))
                    userUpdate[ConstUser.PIN_CODE] = user.pincode;
                if (!String.IsNullOrWhiteSpace(user.phone))
                    userUpdate[ConstUser.PHONE] = user.phone;
                if (!String.IsNullOrWhiteSpace(user.email))
                    userUpdate[ConstUser.EMAIL] = user.email;

                var elasticClient = GetElasticClient();

                var response = elasticClient.Update<User, object>(u => u
                .Index(ElasticMappingConstants.INDEX_NAME)
                .Type(ElasticMappingConstants.TYPE_USER)
                .Id(userElasticId)
                .Doc(userUpdate)
                );

                return response.RequestInformation.Success;
            }
            catch (Exception e)
            {

                throw e;
            }
        }
コード例 #19
0
ファイル: EmployeeManager.cs プロジェクト: vigneshc91/Billing
        public bool DeleteEmployee(Admin admin, String id)
        {
            if (String.IsNullOrWhiteSpace(id)) throw new Exception(ErrorConstants.REQUIRED_FIELD_EMPTY);
            if (admin == null || admin.type != (int)BillingEnums.USER_TYPE.ADMIN) throw new Exception(ErrorConstants.NO_PREVILAGE);

            try
            {
                var employeeElasticId = GetEmployeeId(id);
                if (String.IsNullOrWhiteSpace(employeeElasticId)) throw new Exception(ErrorConstants.EMPLOYEE_NOT_FOUND);

                var elasticClient = GetElasticClient();

                var response = elasticClient.Delete<Employee>(employeeElasticId, d => d
                .Index(ElasticMappingConstants.INDEX_NAME)
                .Type(ElasticMappingConstants.TYPE_EMPLOYEE)
                );

                return response.RequestInformation.Success;
            }
            catch (Exception e)
            {

                throw e;
            }
        }
コード例 #20
0
ファイル: ProductManager.cs プロジェクト: vigneshc91/Billing
        public bool DeleteProduct(Admin admin, string id)
        {
            if (String.IsNullOrWhiteSpace(id)) throw new Exception(ErrorConstants.REQUIRED_FIELD_EMPTY);
            if (admin == null || admin.type != (short)BillingEnums.USER_TYPE.ADMIN) throw new Exception(ErrorConstants.NO_PREVILAGE);

            try
            {
                var productElasticId = GetProductId(id);
                if (String.IsNullOrWhiteSpace(productElasticId))
                    throw new Exception(ErrorConstants.PRODUCT_NOT_FOUND);

                var elasticClient = GetElasticClient();

                var response = elasticClient.Delete<Product>(productElasticId, d => d
                .Index(ElasticMappingConstants.INDEX_NAME)
                .Type(ElasticMappingConstants.TYPE_PRODUCT)
                );

                return response.RequestInformation.Success;
            }
            catch (Exception e)
            {

                throw e;
            }
        }
コード例 #21
0
ファイル: ProductManager.cs プロジェクト: vigneshc91/Billing
        public List<Product> GetProductList(Admin admin, int start, int size)
        {
            if (admin == null || admin.type != (short)BillingEnums.USER_TYPE.ADMIN) throw new Exception(ErrorConstants.NO_PREVILAGE);

            try
            {
                var elasticClient = GetElasticClient();

                var response = elasticClient.Search<Product>(g => g
                .Index(ElasticMappingConstants.INDEX_NAME)
                .Type(ElasticMappingConstants.TYPE_PRODUCT)
                .Skip(start)
                .Take(size)
                );

                List<Product> productList = new List<Product>();

                if(response.Total > 0)
                    foreach (var item in response.Hits)
                        productList.Add(item.Source);

                return productList;
            }
            catch (Exception e)
            {

                throw e;
            } 
        }