public ActionResult CreateJobWorker(MainApplication model, HttpPostedFileBase file)
{
MainApplication mainapp = new MainApplication()
{
user = new User(),
};
JobWorker worker = _JobWorkerService.GetLastRow();
int Val = 0;
int length = 0;
if (worker != null)
{
Val = worker.Id;
Val = Val + 1;
length = Val.ToString().Length;
}
else
{
Val = 1;
length = 1;
}
string Code = _utilityService.getName("JW", length, Val);
string msgbox = string.Empty;
if (file != null)
{
var fileName = Path.GetFileName(file.FileName);
var path = ConfigurationManager.AppSettings["JobWorkerPhotos"].ToString() + "/" + fileName;
file.SaveAs(path);
model.JobWorkerDetails.Photo = fileName;
}
if (!string.IsNullOrEmpty(msgbox))
{
TempData["errorMsg"] = msgbox;
return(RedirectToAction("CreateJobWorker", "JobWork"));
}
Int32 sid = Convert.ToInt32(model.JobWorkerDetails.State);
model.JobWorkerDetails.State = _StateService.GetStateNamebyId(sid);
Int32 cid = Convert.ToInt32(model.JobWorkerDetails.City);
model.JobWorkerDetails.City = _CityService.GetCityNamebyId(cid);
model.JobWorkerDetails.Code = Code;
model.JobWorkerDetails.Status = "Active";
model.JobWorkerDetails.ModifiedOn = DateTime.Now;
model.JobWorkerDetails.CompanyCode = CompanyCode;
_JobWorkerService.Create(model.JobWorkerDetails);
var Id = _JobWorkerService.GetLastRow().Id;
var WorkerId = Encode(Id.ToString());
return(RedirectToAction("CreateJobWorkerDetails/" + WorkerId, "JobWork"));
}
public ActionResult ReplicateTheValues()
{
string procname = "TruncateTable";
_CompanyService.TruncateTable(procname);
//Replicate The Bank Master Values
var BankMasters = TempData["BankMasters"] as IEnumerable <BankMaster>;
foreach (var Bank in BankMasters)
{
Bank.modifiedon = DateTime.Now;
_BankService.CreateBank(Bank);
}
//Replicate The Client Master Values
var ClientMasters = TempData["ClientMasters"] as IEnumerable <ClientMaster>;
foreach (var Client in ClientMasters)
{
Client.ModifiedOn = DateTime.Now;
_ClientMasterService.CreateClient(Client);
}
//Replicate The Client Bank Values
var ClientBanks = TempData["ClientBanks"] as IEnumerable <ClientBankDetail>;
foreach (var Bank in ClientBanks)
{
Bank.ModifiedOn = DateTime.Now;
_ClientBankDetailService.CreateBankDetails(Bank);
}
//Replicate The Designation Master Values
var DesignationMasters = TempData["DesignationMasters"] as IEnumerable <DesignationMaster>;
foreach (var Designation in DesignationMasters)
{
Designation.ModifiedOn = DateTime.Now;
_DesignationMasterService.Create(Designation);
}
//Replicate The Design Master Values
var DesignMasters = TempData["DesignMasters"] as IEnumerable <DesignMaster>;
foreach (var Design in DesignMasters)
{
Design.ModifiedOn = DateTime.Now;
_DesignService.CreateDesign(Design);
}
//Replicate The Brand Master Values
var BrandMasters = TempData["BrandMasters"] as IEnumerable <BrandMaster>;
foreach (var Brand in BrandMasters)
{
Brand.ModifiedOn = DateTime.Now;
_BrandMasterService.Create(Brand);
}
//Replicate The Employee Master Values
var EmployeeMasters = TempData["EmployeeMasters"] as IEnumerable <EmployeeMaster>;
foreach (var Employee in EmployeeMasters)
{
Employee.ModifiedOn = DateTime.Now;
_EmployeeMasterService.CreateEmployee(Employee);
}
//Replicate The Godown Master Values
var GodownMasters = TempData["GodownMasters"] as IEnumerable <GodownMaster>;
foreach (var Godown in GodownMasters)
{
Godown.ModifiedOn = DateTime.Now;
_GodownService.CreateGodown(Godown);
}
//Replicate The Godown Address Values
var GodownAddresses = TempData["GodownAddresses"] as IEnumerable <GodownAddress>;
foreach (var Address in GodownAddresses)
{
_GodownAddressService.CreateGoDown(Address);
}
//Replicate The Item Category Values
var ItemCategory = TempData["ItemCategory"] as IEnumerable <ItemCategory>;
foreach (var Category in ItemCategory)
{
Category.ModifiedOn = DateTime.Now;
_ItemCategoryService.CreateItemCatgory(Category);
}
//Replicate The Item SubCategory Values
var ItemSubCategory = TempData["ItemSubCategory"] as IEnumerable <ItemSubCategory>;
foreach (var SubCategory in ItemSubCategory)
{
SubCategory.ModifiedOn = DateTime.Now;
_ItemSubCategoryService.CreateItemCatgory(SubCategory);
}
//Replicate The Item Master Values
var ItemMasters = TempData["ItemMasters"] as IEnumerable <Item>;
foreach (var Item in ItemMasters)
{
Item.modifedOn = DateTime.Now;
_ItemService.createItem(Item);
}
//Replicate The Non Inventory Item Values
var NonInventoryItems = TempData["NonInventoryItems"] as IEnumerable <NonInventoryItem>;
foreach (var NonInventoryItem in NonInventoryItems)
{
NonInventoryItem.modifedOn = DateTime.Now;
_NonInventoryItemService.createNonInventoryItem(NonInventoryItem);
}
//Replicate The Barcode Numbers Values
var Barcodes = TempData["BarcodeNumbers"] as IEnumerable <BarcodeNumber>;
foreach (var Barcode in Barcodes)
{
_BarcodeNumberService.CreateBarcode(Barcode);
}
//Replicate The Job Worker Values
var JobWorkers = TempData["JobWorkers"] as IEnumerable <JobWorker>;
foreach (var JobWorker in JobWorkers)
{
JobWorker.ModifiedOn = DateTime.Now;
_JobWorkerService.Create(JobWorker);
}
//Replicate The Job Worker Type Values
var JobWorkerTypes = TempData["JobWorkerTypes"] as IEnumerable <JobWorkType>;
foreach (var JobWorkerType in JobWorkerTypes)
{
JobWorkerType.ModifiedOn = DateTime.Now;
_JobWorkTypeService.Create(JobWorkerType);
}
////Replicate The Sales Incentives Values
//var SalesIncentives = TempData["SalesIncentives"] as IEnumerable<SalesIncentiveMaster>;
//foreach (var SalesIncentive in SalesIncentives)
//{
// SalesIncentive.ModifiedOn = DateTime.Now;
// _SalesIncentiveService.CreateSI(SalesIncentive);
//}
//Replicate The Shop Master Values
var ShopMasters = TempData["ShopMasters"] as IEnumerable <ShopMaster>;
foreach (var Shop in ShopMasters)
{
Shop.ModifiedOn = DateTime.Now;
_ShopService.Create(Shop);
}
//Replicate The Type Of Material Values
var TypeOfMaterials = TempData["TypeOfMaterials"] as IEnumerable <TypeOfMaterial>;
foreach (var Material in TypeOfMaterials)
{
Material.ModifiedOn = DateTime.Now;
_TypeOfMaterialService.AddTypeOfMaterial(Material);
}
//Replicate The Unit Master Values
var UnitMasters = TempData["UnitMasters"] as IEnumerable <UnitMaster>;
foreach (var Unit in UnitMasters)
{
Unit.modifiedOn = DateTime.Now;
_UnitService.createunit(Unit);
}
//Replicate The Supplier Master Values
var SupplierMasters = TempData["SupplierMasters"] as IEnumerable <SupplierMaster>;
foreach (var Supplier in SupplierMasters)
{
Supplier.ModifiedOn = DateTime.Now;
_SuppliersMasterService.CreateSupplier(Supplier);
}
//Replicate The Supplier Bank Values
var SupplierBanks = TempData["SupplierBanks"] as IEnumerable <SupplierBankDetail>;
foreach (var Bank in SupplierBanks)
{
Bank.ModifiedOn = DateTime.Now;
_SupplierBankDetailService.CreateBankDetails(Bank);
}
//Replicate The Transport Master Values
var TransportMasters = TempData["TransportMasters"] as IEnumerable <TransportMaster>;
foreach (var Transport in TransportMasters)
{
Transport.ModifiedOn = DateTime.Now;
_TransportService.CreateTransport(Transport);
}
//Replicate The Tranport Bank Values
var TransportBanks = TempData["TransportBanks"] as IEnumerable <TransportBankDetail>;
foreach (var Bank in TransportBanks)
{
Bank.ModifiedOn = DateTime.Now;
_TransportBankDetailService.CreateBankDetails(Bank);
}
//Replicate The User Values
var Users = TempData["Users"] as IEnumerable <User>;
foreach (var User in Users)
{
User.ModifiedBy = DateTime.Now;
_UserService.CreateUser(User);
}
//Replicate The Commission Master Values
var CommissionMasters = TempData["CommissionMasters"] as IEnumerable <CommissionMaster>;
foreach (var Commission in CommissionMasters)
{
Commission.ModifiedOn = DateTime.Now;
_CommissionService.Create(Commission);
}
//Replicate The Module Values
var Modules = TempData["Modules"] as IEnumerable <Module>;
foreach (var module in Modules)
{
_ModuleService.CreateModule(module);
}
//Replicate The UserCredential Values
var UserCredentials = TempData["UserCredentials"] as IEnumerable <UserCredential>;
foreach (var usercredential in UserCredentials)
{
_UserCredentialService.CreateUserCredential(usercredential);
}
//Replicate The Employee Company Values
var EmployeeCompanies = TempData["EmployeeCompanies"] as IEnumerable <EmployeesCompany>;
foreach (var EmpComp in EmployeeCompanies)
{
_EmployeesCompanyService.Create(EmpComp);
}
//CompanyCode = "RetailManagement";
//CompanyName = "RetailManagement";
//DatabaseName = "RetailManagement";
CompanyCode = "A2ZRetail";
CompanyName = "A2ZRetail";
DatabaseName = "A2ZRetail";
return(RedirectToAction("ReplicationDone"));
}
public ActionResult Create(JobWorkerViewModel JobWorkerVm)
{
string[] ProcessIdArr;
if (JobWorkerVm.LedgerAccountGroupId == 0)
{
PrepareViewBag();
return(View(JobWorkerVm).Danger("Account Group field is required"));
}
if (_PersonService.CheckDuplicate(JobWorkerVm.Name, JobWorkerVm.Suffix, JobWorkerVm.PersonId) == true)
{
PrepareViewBag();
return(View(JobWorkerVm).Danger("Combination of name and sufix is duplicate"));
}
if (ModelState.IsValid)
{
if (JobWorkerVm.PersonId == 0)
{
Person person = Mapper.Map <JobWorkerViewModel, Person>(JobWorkerVm);
BusinessEntity businessentity = Mapper.Map <JobWorkerViewModel, BusinessEntity>(JobWorkerVm);
JobWorker JobWorker = Mapper.Map <JobWorkerViewModel, JobWorker>(JobWorkerVm);
PersonAddress personaddress = Mapper.Map <JobWorkerViewModel, PersonAddress>(JobWorkerVm);
LedgerAccount account = Mapper.Map <JobWorkerViewModel, LedgerAccount>(JobWorkerVm);
person.CreatedDate = DateTime.Now;
person.ModifiedDate = DateTime.Now;
person.CreatedBy = User.Identity.Name;
person.ModifiedBy = User.Identity.Name;
person.ObjectState = Model.ObjectState.Added;
new PersonService(_unitOfWork).Create(person);
string Divisions = JobWorkerVm.DivisionIds;
if (Divisions != null)
{
Divisions = "|" + Divisions.Replace(",", "|,|") + "|";
}
businessentity.DivisionIds = Divisions;
string Sites = JobWorkerVm.SiteIds;
if (Sites != null)
{
Sites = "|" + Sites.Replace(",", "|,|") + "|";
}
businessentity.SiteIds = Sites;
_BusinessEntityService.Create(businessentity);
_JobWorkerService.Create(JobWorker);
personaddress.AddressType = AddressTypeConstants.Work;
personaddress.CreatedDate = DateTime.Now;
personaddress.ModifiedDate = DateTime.Now;
personaddress.CreatedBy = User.Identity.Name;
personaddress.ModifiedBy = User.Identity.Name;
personaddress.ObjectState = Model.ObjectState.Added;
_PersonAddressService.Create(personaddress);
account.LedgerAccountName = person.Name;
account.LedgerAccountSuffix = person.Suffix;
account.CreatedDate = DateTime.Now;
account.ModifiedDate = DateTime.Now;
account.CreatedBy = User.Identity.Name;
account.ModifiedBy = User.Identity.Name;
account.ObjectState = Model.ObjectState.Added;
_AccountService.Create(account);
//if (JobWorkerVm.ProcessIds != null && JobWorkerVm.ProcessIds != "")
//{
// ProcessIdArr = JobWorkerVm.ProcessIds.Split(new Char[] { ',' });
// for (int i = 0; i <= ProcessIdArr.Length - 1; i++)
// {
// PersonProcess personprocess = new PersonProcess();
// personprocess.PersonId = JobWorker.PersonID;
// personprocess.ProcessId = Convert.ToInt32(ProcessIdArr[i]);
// personprocess.CreatedDate = DateTime.Now;
// personprocess.ModifiedDate = DateTime.Now;
// personprocess.CreatedBy = User.Identity.Name;
// personprocess.ModifiedBy = User.Identity.Name;
// personprocess.ObjectState = Model.ObjectState.Added;
// _PersonProcessService.Create(personprocess);
// }
//}
if (JobWorkerVm.PanNo != "" && JobWorkerVm.PanNo != null)
{
PersonRegistration personregistration = new PersonRegistration();
personregistration.RegistrationType = PersonRegistrationType.PANNo;
personregistration.RegistrationNo = JobWorkerVm.PanNo;
personregistration.CreatedDate = DateTime.Now;
personregistration.ModifiedDate = DateTime.Now;
personregistration.CreatedBy = User.Identity.Name;
personregistration.ModifiedBy = User.Identity.Name;
personregistration.ObjectState = Model.ObjectState.Added;
_PersonRegistrationService.Create(personregistration);
}
try
{
_unitOfWork.Save();
}
catch (Exception ex)
{
string message = _exception.HandleException(ex);
ModelState.AddModelError("", message);
PrepareViewBag();
return(View(JobWorkerVm));
}
#region
//Saving Images if any uploaded after UnitOfWorkSave
if (Request.Files[0] != null && Request.Files[0].ContentLength > 0)
{
//For checking the first time if the folder exists or not-----------------------------
string uploadfolder;
int MaxLimit;
int.TryParse(ConfigurationManager.AppSettings["MaxFileUploadLimit"], out MaxLimit);
var x = (from iid in db.Counter
select iid).FirstOrDefault();
if (x == null)
{
uploadfolder = System.Guid.NewGuid().ToString();
Counter img = new Counter();
img.ImageFolderName = uploadfolder;
img.ModifiedBy = User.Identity.Name;
img.CreatedBy = User.Identity.Name;
img.ModifiedDate = DateTime.Now;
img.CreatedDate = DateTime.Now;
new CounterService(_unitOfWork).Create(img);
_unitOfWork.Save();
}
else
{
uploadfolder = x.ImageFolderName;
}
//For checking if the image contents length is greater than 100 then create a new folder------------------------------------
if (!Directory.Exists(System.Web.HttpContext.Current.Request.MapPath("~/Uploads/" + uploadfolder)))
{
Directory.CreateDirectory(System.Web.HttpContext.Current.Request.MapPath("~/Uploads/" + uploadfolder));
}
int count = Directory.GetFiles(System.Web.HttpContext.Current.Request.MapPath("~/Uploads/" + uploadfolder)).Length;
if (count >= MaxLimit)
{
uploadfolder = System.Guid.NewGuid().ToString();
var u = new CounterService(_unitOfWork).Find(x.CounterId);
u.ImageFolderName = uploadfolder;
new CounterService(_unitOfWork).Update(u);
_unitOfWork.Save();
}
//Saving Thumbnails images:
Dictionary <string, string> versions = new Dictionary <string, string>();
//Define the versions to generate
versions.Add("_thumb", "maxwidth=100&maxheight=100"); //Crop to square thumbnail
versions.Add("_medium", "maxwidth=200&maxheight=200"); //Fit inside 400x400 area, jpeg
string temp2 = "";
string filename = System.Guid.NewGuid().ToString();
foreach (string filekey in System.Web.HttpContext.Current.Request.Files.Keys)
{
HttpPostedFile pfile = System.Web.HttpContext.Current.Request.Files[filekey];
if (pfile.ContentLength <= 0)
{
continue; //Skip unused file controls.
}
temp2 = Path.GetExtension(pfile.FileName);
string uploadFolder = System.Web.HttpContext.Current.Request.MapPath("~/Uploads/" + uploadfolder);
if (!Directory.Exists(uploadFolder))
{
Directory.CreateDirectory(uploadFolder);
}
string filecontent = Path.Combine(uploadFolder, JobWorkerVm.Name + "_" + filename);
//pfile.SaveAs(filecontent);
ImageBuilder.Current.Build(new ImageJob(pfile, filecontent, new Instructions(), false, true));
//Generate each version
foreach (string suffix in versions.Keys)
{
if (suffix == "_thumb")
{
string tuploadFolder = System.Web.HttpContext.Current.Request.MapPath("~/Uploads/" + uploadfolder + "/Thumbs");
if (!Directory.Exists(tuploadFolder))
{
Directory.CreateDirectory(tuploadFolder);
}
//Generate a filename (GUIDs are best).
string tfileName = Path.Combine(tuploadFolder, JobWorkerVm.Name + "_" + filename);
//Let the image builder add the correct extension based on the output file type
//fileName = ImageBuilder.Current.Build(file, fileName, new ResizeSettings(versions[suffix]), false, true);
ImageBuilder.Current.Build(new ImageJob(pfile, tfileName, new Instructions(versions[suffix]), false, true));
}
else if (suffix == "_medium")
{
string tuploadFolder = System.Web.HttpContext.Current.Request.MapPath("~/Uploads/" + uploadfolder + "/Medium");
if (!Directory.Exists(tuploadFolder))
{
Directory.CreateDirectory(tuploadFolder);
}
//Generate a filename (GUIDs are best).
string tfileName = Path.Combine(tuploadFolder, JobWorkerVm.Name + "_" + filename);
//Let the image builder add the correct extension based on the output file type
//fileName = ImageBuilder.Current.Build(file, fileName, new ResizeSettings(versions[suffix]), false, true);
ImageBuilder.Current.Build(new ImageJob(pfile, tfileName, new Instructions(versions[suffix]), false, true));
}
}
//var tempsave = _FinishedProductService.Find(pt.ProductId);
person.ImageFileName = JobWorkerVm.Name + "_" + filename + temp2;
person.ImageFolderName = uploadfolder;
person.ObjectState = Model.ObjectState.Modified;
_PersonService.Update(person);
_unitOfWork.Save();
}
}
#endregion
//return RedirectToAction("Create").Success("Data saved successfully");
return(RedirectToAction("Edit", new { id = JobWorker.PersonID }).Success("Data saved Successfully"));
}
else
{
List <LogTypeViewModel> LogList = new List <LogTypeViewModel>();
//string tempredirect = (Request["Redirect"].ToString());
Person person = Mapper.Map <JobWorkerViewModel, Person>(JobWorkerVm);
BusinessEntity businessentity = Mapper.Map <JobWorkerViewModel, BusinessEntity>(JobWorkerVm);
JobWorker JobWorker = Mapper.Map <JobWorkerViewModel, JobWorker>(JobWorkerVm);
PersonAddress personaddress = _PersonAddressService.Find(JobWorkerVm.PersonAddressID);
LedgerAccount account = _AccountService.Find(JobWorkerVm.AccountId);
PersonRegistration PersonPan = _PersonRegistrationService.Find(JobWorkerVm.PersonRegistrationPanNoID);
PersonAddress ExRec = new PersonAddress();
ExRec = Mapper.Map <PersonAddress>(personaddress);
LedgerAccount ExRecLA = new LedgerAccount();
ExRecLA = Mapper.Map <LedgerAccount>(account);
PersonRegistration ExRecP = new PersonRegistration();
ExRecP = Mapper.Map <PersonRegistration>(PersonPan);
StringBuilder logstring = new StringBuilder();
person.ModifiedDate = DateTime.Now;
person.ModifiedBy = User.Identity.Name;
new PersonService(_unitOfWork).Update(person);
string Divisions = JobWorkerVm.DivisionIds;
if (Divisions != null)
{
Divisions = "|" + Divisions.Replace(",", "|,|") + "|";
}
businessentity.DivisionIds = Divisions;
string Sites = JobWorkerVm.SiteIds;
if (Sites != null)
{
Sites = "|" + Sites.Replace(",", "|,|") + "|";
}
businessentity.SiteIds = Sites;
_BusinessEntityService.Update(businessentity);
_JobWorkerService.Update(JobWorker);
personaddress.Address = JobWorkerVm.Address;
personaddress.CityId = JobWorkerVm.CityId;
personaddress.Zipcode = JobWorkerVm.Zipcode;
personaddress.ModifiedDate = DateTime.Now;
personaddress.ModifiedBy = User.Identity.Name;
personaddress.ObjectState = Model.ObjectState.Modified;
_PersonAddressService.Update(personaddress);
LogList.Add(new LogTypeViewModel
{
ExObj = ExRec,
Obj = personaddress,
});
account.LedgerAccountName = person.Name;
account.LedgerAccountSuffix = person.Suffix;
account.LedgerAccountGroupId = JobWorkerVm.LedgerAccountGroupId;
account.ModifiedDate = DateTime.Now;
account.ModifiedBy = User.Identity.Name;
_AccountService.Update(account);
LogList.Add(new LogTypeViewModel
{
ExObj = ExRecLA,
Obj = account,
});
//if (JobWorkerVm.ProcessIds != "" && JobWorkerVm.ProcessIds != null)
//{
// IEnumerable<PersonProcess> personprocesslist = _PersonProcessService.GetPersonProcessList(JobWorkerVm.PersonId);
// foreach (PersonProcess item in personprocesslist)
// {
// new PersonProcessService(_unitOfWork).Delete(item.PersonProcessId);
// }
// ProcessIdArr = JobWorkerVm.ProcessIds.Split(new Char[] { ',' });
// for (int i = 0; i <= ProcessIdArr.Length - 1; i++)
// {
// PersonProcess personprocess = new PersonProcess();
// personprocess.PersonId = JobWorker.PersonID;
// personprocess.ProcessId = Convert.ToInt32(ProcessIdArr[i]);
// personprocess.CreatedDate = DateTime.Now;
// personprocess.ModifiedDate = DateTime.Now;
// personprocess.CreatedBy = User.Identity.Name;
// personprocess.ModifiedBy = User.Identity.Name;
// personprocess.ObjectState = Model.ObjectState.Added;
// _PersonProcessService.Create(personprocess);
// }
//}
if (JobWorkerVm.PanNo != null && JobWorkerVm.PanNo != "")
{
if (PersonPan != null)
{
PersonPan.RegistrationNo = JobWorkerVm.PanNo;
_PersonRegistrationService.Update(PersonPan);
LogList.Add(new LogTypeViewModel
{
ExObj = ExRecP,
Obj = PersonPan,
});
}
else
{
PersonRegistration personregistration = new PersonRegistration();
personregistration.PersonId = JobWorkerVm.PersonId;
personregistration.RegistrationType = PersonRegistrationType.PANNo;
personregistration.RegistrationNo = JobWorkerVm.PanNo;
personregistration.CreatedDate = DateTime.Now;
personregistration.ModifiedDate = DateTime.Now;
personregistration.CreatedBy = User.Identity.Name;
personregistration.ModifiedBy = User.Identity.Name;
personregistration.ObjectState = Model.ObjectState.Added;
_PersonRegistrationService.Create(personregistration);
}
}
XElement Modifications = new ModificationsCheckService().CheckChanges(LogList);
try
{
_unitOfWork.Save();
}
catch (Exception ex)
{
string message = _exception.HandleException(ex);
ModelState.AddModelError("", message);
PrepareViewBag();
return(View("Create", JobWorkerVm));
}
LogActivity.LogActivityDetail(new ActiivtyLogViewModel
{
DocTypeId = new DocumentTypeService(_unitOfWork).FindByName(MasterDocCategoryConstants.JobWorker).DocumentTypeId,
DocId = JobWorkerVm.PersonId,
ActivityType = (int)ActivityTypeContants.Modified,
DocNo = JobWorkerVm.Name,
xEModifications = Modifications,
});
//End of Saving ActivityLog
#region
//Saving Image if file is uploaded
if (Request.Files[0] != null && Request.Files[0].ContentLength > 0)
{
string uploadfolder = JobWorkerVm.ImageFolderName;
string tempfilename = JobWorkerVm.ImageFileName;
if (uploadfolder == null)
{
var x = (from iid in db.Counter
select iid).FirstOrDefault();
if (x == null)
{
uploadfolder = System.Guid.NewGuid().ToString();
Counter img = new Counter();
img.ImageFolderName = uploadfolder;
img.ModifiedBy = User.Identity.Name;
img.CreatedBy = User.Identity.Name;
img.ModifiedDate = DateTime.Now;
img.CreatedDate = DateTime.Now;
new CounterService(_unitOfWork).Create(img);
_unitOfWork.Save();
}
else
{
uploadfolder = x.ImageFolderName;
}
}
//Deleting Existing Images
var xtemp = System.Web.HttpContext.Current.Server.MapPath("~/Uploads/" + uploadfolder + "/" + tempfilename);
if (System.IO.File.Exists(System.Web.HttpContext.Current.Server.MapPath("~/Uploads/" + uploadfolder + "/" + tempfilename)))
{
System.IO.File.Delete(System.Web.HttpContext.Current.Server.MapPath("~/Uploads/" + uploadfolder + "/" + tempfilename));
}
//Deleting Thumbnail Image:
if (System.IO.File.Exists(System.Web.HttpContext.Current.Server.MapPath("~/Uploads/" + uploadfolder + "/Thumbs/" + tempfilename)))
{
System.IO.File.Delete(System.Web.HttpContext.Current.Server.MapPath("~/Uploads/" + uploadfolder + "/Thumbs/" + tempfilename));
}
//Deleting Medium Image:
if (System.IO.File.Exists(System.Web.HttpContext.Current.Server.MapPath("~/Uploads/" + uploadfolder + "/Medium/" + tempfilename)))
{
System.IO.File.Delete(System.Web.HttpContext.Current.Server.MapPath("~/Uploads/" + uploadfolder + "/Medium/" + tempfilename));
}
//Saving Thumbnails images:
Dictionary <string, string> versions = new Dictionary <string, string>();
//Define the versions to generate
versions.Add("_thumb", "maxwidth=100&maxheight=100"); //Crop to square thumbnail
versions.Add("_medium", "maxwidth=200&maxheight=200"); //Fit inside 400x400 area, jpeg
string temp2 = "";
string filename = System.Guid.NewGuid().ToString();
foreach (string filekey in System.Web.HttpContext.Current.Request.Files.Keys)
{
HttpPostedFile pfile = System.Web.HttpContext.Current.Request.Files[filekey];
if (pfile.ContentLength <= 0)
{
continue; //Skip unused file controls.
}
temp2 = Path.GetExtension(pfile.FileName);
string uploadFolder = System.Web.HttpContext.Current.Request.MapPath("~/Uploads/" + uploadfolder);
if (!Directory.Exists(uploadFolder))
{
Directory.CreateDirectory(uploadFolder);
}
string filecontent = Path.Combine(uploadFolder, JobWorkerVm.Name + "_" + filename);
//pfile.SaveAs(filecontent);
ImageBuilder.Current.Build(new ImageJob(pfile, filecontent, new Instructions(), false, true));
//Generate each version
foreach (string suffix in versions.Keys)
{
if (suffix == "_thumb")
{
string tuploadFolder = System.Web.HttpContext.Current.Request.MapPath("~/Uploads/" + uploadfolder + "/Thumbs");
if (!Directory.Exists(tuploadFolder))
{
Directory.CreateDirectory(tuploadFolder);
}
//Generate a filename (GUIDs are best).
string tfileName = Path.Combine(tuploadFolder, JobWorkerVm.Name + "_" + filename);
//Let the image builder add the correct extension based on the output file type
//fileName = ImageBuilder.Current.Build(file, fileName, new ResizeSettings(versions[suffix]), false, true);
ImageBuilder.Current.Build(new ImageJob(pfile, tfileName, new Instructions(versions[suffix]), false, true));
}
else if (suffix == "_medium")
{
string tuploadFolder = System.Web.HttpContext.Current.Request.MapPath("~/Uploads/" + uploadfolder + "/Medium");
if (!Directory.Exists(tuploadFolder))
{
Directory.CreateDirectory(tuploadFolder);
}
//Generate a filename (GUIDs are best).
string tfileName = Path.Combine(tuploadFolder, JobWorkerVm.Name + "_" + filename);
//Let the image builder add the correct extension based on the output file type
//fileName = ImageBuilder.Current.Build(file, fileName, new ResizeSettings(versions[suffix]), false, true);
ImageBuilder.Current.Build(new ImageJob(pfile, tfileName, new Instructions(versions[suffix]), false, true));
}
}
}
var temsave = _PersonService.Find(person.PersonID);
temsave.ImageFileName = temsave.Name + "_" + filename + temp2;
temsave.ImageFolderName = uploadfolder;
_PersonService.Update(temsave);
_unitOfWork.Save();
}
#endregion
return(RedirectToAction("Index").Success("Data saved successfully"));
}
}
PrepareViewBag();
return(View(JobWorkerVm));
}
