public bool AddBranch(xbranch branch)
{
var db = new dbsmappEntities();
var brn = db.xbranches.FirstOrDefault(s => s.branchcode.Equals(branch.branchcode));
if (brn == null)
{
NullFiller.FillNullFields <xbranch>(branch);
Capitalize.UppercaseClassFields <xbranch>(branch);
db.xbranches.Add(branch);
}
else
{
NullFiller.FillNullFields <xbranch>(branch);
Capitalize.UppercaseClassFields <xbranch>(branch);
brn.branchname = branch.branchname;
brn.remarks = branch.remarks;
}
db.SaveChanges();
return(true);
}
public void CapitalizationTest()
{
string item = "rodrigo fernandes .,po po po portela;";
string exp = "Rodrigo Fernandes .,Po Po Po Portela;";
Assert.AreEqual <string>(exp, Capitalize.Intercept(item));
}
public bool AddDepartment(sdepartment Department)
{
var db = new dbsmappEntities();
var dept = db.sdepartments.FirstOrDefault(s => s.deptcode.Equals(Department.deptcode));
if (dept == null)
{
Department.status = "activated";
NullFiller.FillNullFields <sdepartment>(Department);
Capitalize.UppercaseClassFields <sdepartment>(Department);
db.sdepartments.Add(Department);
}
else
{
NullFiller.FillNullFields <sdepartment>(Department);
Capitalize.UppercaseClassFields <sdepartment>(Department);
dept.deptcode = Department.deptcode;
dept.deptname = Department.deptname;
dept.remarks = Department.remarks;
dept.status = "ACTIVATED";
}
db.SaveChanges();
return(true);
}
public bool AddProductPrice(iproductprice price)
{
var db = new dbsmappEntities();
var pprice = db.iproductprices.FirstOrDefault(s => s.itemcode.Equals(price.itemcode));
if (pprice == null)
{
price.status = "new";
NullFiller.FillNullFields <iproductprice>(price);
Capitalize.UppercaseClassFields <iproductprice>(price);
db.iproductprices.Add(price);
}
else
{
pprice.sellingprice = price.sellingprice;
pprice.purchasingprice = price.purchasingprice;
pprice.vatprice = price.vatprice;
pprice.remarks = price.remarks;
}
db.SaveChanges();
return(true);
}
public bool AddProduct(iproduct product)
{
var db = new dbsmappEntities();
var prod = db.iproducts.FirstOrDefault(s => s.barcode.Equals(product.barcode));
if (prod == null)
{
product.status = "activated";
NullFiller.FillNullFields <iproduct>(product);
Capitalize.UppercaseClassFields <iproduct>(product);
db.iproducts.Add(product);
var files = Request.Files;
if (files.Count != 0)
{
new ImageFunc().UploadProductPic(Request.Files, product.itemcode + "P");
}
db.SaveChanges();
return(true);
}
else
{
return(false);
}
}
public void CapitalizeEveryWordInThisSentence()
{
var cap = new Capitalize();
var ex = "I Wrote Some Code That Will Capitalize The First Letter Of Every Single Word In This Sentence.";
var actual = cap.capitalizeFirstLetterOfEachWord("i wrote some code that will capitalize the first letter of every single word in this sentence.");
Assert.AreEqual(ex, actual);
}
public void CapitlizeWordWithNumber()
{
var cap = new Capitalize();
var expected = "4all purpose flour";
var actual = cap.capitalizeFirstLetterOfEachWord("4all purpose flour");
Assert.AreEqual(expected, actual);
}
public void CapitlizeWordWithSpecialChar()
{
var cap = new Capitalize();
var ex = "$all purpose flour";
var actual = cap.capitalizeFirstLetterOfEachWord("$all purpose flour");
Assert.AreEqual(ex, actual);
}
public void CapitalizeEveryWord2()
{
var cap = new Capitalize();
var expected = "Oh The Glory Of The Morning Blossoms";
var actual = cap.capitalizeFirstLetterOfEachWord("oh the glory of the morning blossoms");
Assert.AreEqual(expected, actual);
}
public async Task <bool> UserSubmit(rUser model)
{
NullFiller.FillNullFields <rUser>(model);
Capitalize.UppercaseClassFields <rUser>(model);
var db = new dbsmappEntities();
var isExist = db.userapps.FirstOrDefault(s => s.userid.Equals(model.userid));
if (isExist != null)
{
return(false);
}
var emailAdd = model.userid + "@danubeco.com";
var newuserid = model.userid + "JED";
var user = new User {
UserName = newuserid, Email = emailAdd, Region = "JED"
};
//var rnpw = System.Web.Security.Membership.GeneratePassword(6, 0);
var result = await UserManager.CreateAsync(user, "12345678");
if (!result.Succeeded)
{
return(false);
}
var currentUser = await UserManager.FindByEmailAsync(emailAdd);
await UserManager.AddToRolesAsync(currentUser.Id, model.role);
db.userapps.Add(new userapp()
{
userid = newuserid,
empid = model.userid,
name = model.name,
role = model.role,
status = "activated",
login = DateTime.Today,
password = "******"
});
var files = Request.Files;
if (files.Count != 0)
{
new ImageFunc().UploadProductPic(Request.Files, newuserid);
}
db.SaveChanges();
return(true);
}
public void CapitalizeEveryWord()
{
var capitalize = new Capitalize();
var expected = "All Purpose Flour";
var expected2 = "All-Purpose Flour";
var actual = capitalize.capitalizeFirstLetterOfEachWord("all purpose flour");
var actual2 = capitalize.capitalizeFirstLetterOfEachWord("all-purpose flour");
Assert.AreEqual(expected, actual);
Assert.AreEqual(expected2, actual2);
}
public async Task <bool> AddSupplier(rX supplier)
{
var db = new dnbmssqlEntities();
NullFiller.FillNullFields <rX>(supplier);
Capitalize.UppercaseClassFields <rX>(supplier);
// Supplier Login
var username = supplier.idd + supplier.region;
var sup_user = db.C_User.FirstOrDefault(s => s.UserName.Equals(username));
if (sup_user == null)
{
var user = new User {
UserName = username, Email = username + "@danubeco.com", Region = supplier.region
};
try
{
var result = await UserManager.CreateAsync(user, supplier.password);
if (!result.Succeeded)
{
return(false);
}
else
{
SupplierInfo(supplier);
return(true);
}
}
catch (Exception)
{
return(false);
}
}
else
{
var user = await UserManager.FindByIdAsync(sup_user.UserId);
user.PasswordHash = UserManager.PasswordHasher.HashPassword(supplier.password);
await UserManager.UpdateAsync(user);
SupplierInfo(supplier);
return(true);
}
}
public CasedFIO Get(string surname, string firstName, Gender gender)
{
CasedFIO result = new CasedFIO();
Capitalize cap = new Capitalize();
surname = cap.Capitalizer(surname);
firstName = cap.Capitalizer(firstName);
var sc = mixedCasers.SurnameCaser;
var fc = mixedCasers.FirstNameCaser;
result.Nominative.Surname = sc.GetCase(surname, Gender.Undefined, Case.Nominative);
result.Nominative.FirstName = fc.GetCase(firstName, Gender.Undefined, Case.Nominative);
result.Ablative.Surname = sc.GetCase(surname, gender, Case.Ablative);
result.Dative.Surname = sc.GetCase(surname, gender, Case.Dative);
result.Genitive.Surname = sc.GetCase(surname, gender, Case.Genitive);
result.Prepositional.Surname = sc.GetCase(surname, gender, Case.Prepositional);
result.Ablative.FirstName = fc.GetCase(firstName, gender, Case.Ablative);
result.Dative.FirstName = fc.GetCase(firstName, gender, Case.Dative);
result.Genitive.FirstName = fc.GetCase(firstName, gender, Case.Genitive);
result.Prepositional.FirstName = fc.GetCase(firstName, gender, Case.Prepositional);
Action <CasedSimpleFIO> fullcalcer = (fio) => fio.Full = fio.Surname + " " + fio.FirstName;
Action <CasedSimpleFIO> abbrcalcer = (fio) => fio.Abbr = fio.Surname + " " + fio.FirstName[0] + ".";
Action <CasedSimpleFIO> iocalcer = (fio) => fio.IO = fio.FirstName;
Action <CasedSimpleFIO> complexcalcer = fio =>
{
fullcalcer(fio);
abbrcalcer(fio);
iocalcer(fio);
};
complexcalcer(result.Genitive);
complexcalcer(result.Ablative);
complexcalcer(result.Dative);
complexcalcer(result.Prepositional);
complexcalcer(result.Nominative);
return(result);
}
public bool AddServices(nservice services)
{
var db = new dbsmappEntities();
var serv = db.nservices.FirstOrDefault(s => s.servicescode.Equals(services.servicescode));
if (serv == null)
{
NullFiller.FillNullFields <nservice>(services);
Capitalize.UppercaseClassFields <nservice>(services);
db.nservices.Add(services);
}
else
{
NullFiller.FillNullFields <nservice>(services);
Capitalize.UppercaseClassFields <nservice>(services);
serv.servicename = services.servicename;
serv.description = services.description;
serv.departmentid = services.departmentid;
serv.nprice = services.nprice;
serv.sprice = services.sprice;
serv.minutes = services.minutes;
serv.hours = services.hours;
serv.fixedcommission = services.fixedcommission;
serv.remarks = services.remarks;
serv.status = services.status;
}
var files = Request.Files;
if (files.Count != 0)
{
new ImageFunc().UploadProductPic(Request.Files, services.servicescode + "S");
}
db.SaveChanges();
return(true);
}
public bool UpdateProduct(iproduct product)
{
var db = new dbsmappEntities();
var prod = db.iproducts.FirstOrDefault(s => s.itemcode.Equals(product.itemcode));
if (prod == null)
{
return(false);
}
else
{
NullFiller.FillNullFields <iproduct>(product);
Capitalize.UppercaseClassFields <iproduct>(product);
prod.itemcode = product.itemcode;
prod.barcode = product.barcode;
prod.modelno = product.modelno;
prod.serialno = product.serialno;
prod.arname = product.arname;
prod.enname = product.enname;
prod.arshortname = product.arshortname;
prod.enshortname = product.enshortname;
prod.size = product.size;
prod.unit = product.unit;
prod.remarks = product.remarks;
prod.status = product.status;
var files = Request.Files;
if (files.Count != 0)
{
new ImageFunc().UploadProductPic(Request.Files, product.itemcode + "P");
}
db.SaveChanges();
return(true);
}
}
public CapitalizeFirst(Capitalize capitalize)
{
this.capitalize = capitalize;
}
public void Setup()
{
request = new CapitalizeRequest();
cap = new Capitalize();
response = new CapitalizeResponse();
}
public CustomerController(ICustomer customerServices)
{
_customerServices = customerServices;
_capitalize = new Capitalize();
}
public void CapitalizeWords_NullArgument_ThrowArgNullException()
{
Assert.That(() => Capitalize.CapitalizeWords(null), Throws.ArgumentNullException);
}
public EnvSettings(bool Capitalize) => PopulateProperties(Capitalize : Capitalize);
public ProductController(IProduct productrServices)
{
_productrServices = productrServices;
_capitalize = new Capitalize();
}
public StoreController(IStore storeServices)
{
_storeServices = storeServices;
_capitalize = new Capitalize();
}
public EnvSettings(string prefix = "", bool?Capitalize = true) => PopulateProperties(Prefix : prefix, Capitalize : Capitalize);
public void CapitalizeWords_WhenCalled_ReturnCapitalizedString(string str, string expectedResult)
{
var result = Capitalize.CapitalizeWords(str);
Assert.That(result, Is.EqualTo(expectedResult));
}
