public async Task <IActionResult> EditContract(ContractViewModel model)
{
if (ModelState.IsValid)
{
var contract = await _converterHelper.ToContractAsync(model, false);
_dataContext.Contracts.Update(contract);
await _dataContext.SaveChangesAsync();
return(RedirectToAction($"{nameof(DetailsProperty)}/{model.PropertyId}"));
}
return(View(model));
}
public async Task <IActionResult> AddContract(ContractViewModel view)
{
if (ModelState.IsValid)
{
var contract = await _converterHelper.ToContractAsync(view, true);
_dataContext.Contracts.Add(contract);
await _dataContext.SaveChangesAsync();
return(RedirectToAction($"{nameof(DetailsProperty)}/{view.PropertyId}"));
}
return(View(view));
}
public async Task <IActionResult> AddContract(ContractViewModel model)
{
if (ModelState.IsValid)
{
var contract = await _converterHelper.ToContractAsync(model, true);
_dataContext.Contracts.Add(contract);
await _dataContext.SaveChangesAsync();
return(RedirectToAction($"{nameof(DetailsProperty)}/{model.PropertyId}"));
}
model.Lessees = _combosHelper.GetComboLessees();
return(View(model));
}
public async Task <ActionResult> Create(ContractViewModel contract)
{
var tenants = (await _tenantRepository.GetAllAsync()).OrderBy(t => t.Name);
var rooms = (await _roomRepository.GetAllAsync()).OrderBy(r => r.Address);
var accrualTypes = (await _accrualTypeRepository.GetAllAsync()).OrderBy(t => t.Name);
var tenantsSelectList = new SelectList(tenants, "Id", "Name", tenants.First(t => t.Id == contract.TenantId));
var roomsSelectList = new SelectList(rooms, "Id", "Address", rooms.First(r => r.Id == contract.RoomId));
var accrualTypesSelectList = new SelectList(accrualTypes, "Id", "Name", accrualTypes.First(t => t.Id == contract.AccrualTypeId));
contract.Id = System.Guid.NewGuid().ToString();
contract.Tenants = tenantsSelectList;
contract.Rooms = roomsSelectList;
contract.AccrualTypes = accrualTypesSelectList;
var accrual = ContractViewModel.FromContractViewModel(contract);
var room = await _roomRepository.GetByIdAsync(contract.RoomId);
if (!ModelState.IsValid)
{
return(View(contract));
}
if (contract.AccrualTypeId == "d739e49d-6219-46e1-968d-498e80a5681c" && room.IsOccupied)
{
ModelState.AddModelError(string.Empty, "Выбранное помещение уже арендуется.");
return(View(contract));
}
if (contract.AccrualTypeId != "d739e49d-6219-46e1-968d-498e80a5681c" && !room.IsOccupied)
{
ModelState.AddModelError(string.Empty, @"Для составления договора на
сопроводительные услуги необходимо выбрать помещение, на которое составлен договор аренды.");
return(View(contract));
}
try
{
await _contractRepository.AddAsync(accrual);
await _roomRepository.UpdateAsync(room);
return(RedirectToAction(nameof(Index)));
}
catch (Exception e)
{
ModelState.AddModelError("", e.Message);
return(View(contract));
}
}
public JsonResult EditContract(ContractViewModel model)
{
var result = new { Success = "true", Message = "Success" };
if (ModelState.IsValid)
{
try
{
if (model.DateTo.HasValue && model.DateFrom >= model.DateTo.Value)
{
result = new { Success = "false", Message = "Data zakończenia umowy musi być późniejsza niż data rozpoczęcia." };
return(Json(result, JsonRequestBehavior.AllowGet));
}
var employee = _employeeService.GetById(model.EmployeeId);
var lastContract = employee.Contracts?.Where(x => !x.IsDeleted).OrderByDescending(x => x.Id).FirstOrDefault();
if ((lastContract != null && !lastContract.DateTo.HasValue) || (lastContract != null && lastContract.DateTo.Value > model.DateFrom))
{
result = new { Success = "false", Message = "Data rozpoczęcia nowej umowy musi być późniejsza niż data zakończenia poprzedniej." };
return(Json(result, JsonRequestBehavior.AllowGet));
}
var contract = Mapper.Map <Contract>(model);
contract.UpdatedDate = DateTime.Now;
_contractService.Update(contract);
return(Json(result, JsonRequestBehavior.AllowGet));
}
catch (Exception e)
{
logger.Error(e, e.Message);
result = new { Success = "false", Message = WebResources.ErrorMessage };
return(Json(result, JsonRequestBehavior.AllowGet));
}
}
else
{
var error = ModelState.Values.SelectMany(v => v.Errors).FirstOrDefault().ErrorMessage;
result = new { Success = "false", Message = error };
return(Json(result, JsonRequestBehavior.AllowGet));
}
}
public JsonResult Index(int page = 1, int rows = 10, DateTime?ETA = null,
string filterValue = "")
{
DateTime dt1 = DateTime.Now;
ContractListCondition condition = new ContractListCondition()
{
IsEnable = true,
Page = page,
Rows = rows,
ListInclude = ContractListInclude.BothOrderAndSaleContract
| ContractListInclude.WithAggregations
| ContractListInclude.WithHarborAgent
| ContractListInclude.WithHongkongLogistics
| ContractListInclude.WithMainlandLogistics
| ContractListInclude.WithOrderCompensation
| ContractListInclude.WithProductStock
| ContractListInclude.WithSaleCompensation,
UserName = HttpContext.User.Identity.Name,
OrderField = ContractOrderField.CTIME_DESC,
ProductFullNameFilterValue = filterValue,
};
if (ETA.HasValue)
{
condition.ETAFrom = ETA.GetValueOrDefault().Date;
condition.ETATo = ETA.GetValueOrDefault().Date.AddDays(1);
}
ContractViewModel contractViewModel = ContractManager.Instance.GetIndexListContracts(
HttpContext.GetOwinContext(), dxContext, condition);
TimeSpan span1 = DateTime.Now.Subtract(dt1);
System.Diagnostics.Debug.WriteLine(string.Format(
"OrderContractController Index part1 :{0},{1},{2},{3}; TimeSpan:{4}", page, rows, ETA, filterValue, span1.TotalMilliseconds));
IEnumerable <ContractInfo> list = contractViewModel.ContractItems;
TimeSpan span2 = DateTime.Now.Subtract(dt1);
System.Diagnostics.Debug.WriteLine(string.Format(
"OrderContractController Index:{0},{1},{2},{3}; TimeSpan:{4}", page, rows, ETA, filterValue, span2.TotalMilliseconds));
return(Json(new
{
total = contractViewModel.Aggregations.Count.GetValueOrDefault(),
rows = list
}));
}
public async Task <Contract> ToContractAsync(ContractViewModel model, bool isNew)
{
return(new Contract
{
EndDate = model.EndDate.ToUniversalTime(), //Esta ultima propiedad para guarar en fecha universal
Id = isNew ? 0 : model.Id, //si es nuevo carga 0, sino lo que traiga model
IsActive = model.IsActive,
Lessee = await _dataContext.Lessees.FindAsync(model.LesseeId),
Owner = await _dataContext.Owners.FindAsync(model.OwnerId),
Price = model.Price,
Property = await _dataContext.Properties.FindAsync(model.PropertyId),
Remarks = model.Remarks,
StartDate = model.StartDate.ToUniversalTime(),
});
}
public async Task <Contract> ToContractAsync(ContractViewModel view)
{
return(new Contract
{
EndDate = view.EndDate,
IsActive = view.IsActive,
Lessee = await _dataContext.Lessees.FindAsync(view.LesseeId),
Owner = await _dataContext.Owners.FindAsync(view.OwnerId),
Price = view.Price,
Property = await _dataContext.Properties.FindAsync(view.PropertyId),
Remarks = view.Remarks,
StartDate = view.StartDate,
Id = view.Id
});
}
public ActionResult Create(ContractViewModel viewModel)
{
var contract = new Contract
{
Name = viewModel.Name,
Experience = viewModel.Experience,
TypeId = viewModel.Type,
Salary = viewModel.Salary
};
_context.Contracts.Add(contract);
_context.SaveChanges();
return(RedirectToAction("Create", "Contracts"));
}
public void Update(ContractViewModel model)
{
var contractType = AutoMapper.Mapper.Map <ContractViewModel, Contract>(model);
if (string.IsNullOrEmpty(contractType.Document))
{
var old = _repository.FindById(model.Id);
if (old != null)
{
contractType.Document = old.Document;
}
}
_repository.Update(contractType);
}
public async Task <Contract> ToContractAsync(ContractViewModel model, bool isNew)
{
return(new Contract
{
EndDate = model.EndDate.ToUniversalTime(),
Id = isNew ? 0: model.Id,
IsActive = model.IsActive,
Lessee = await _dataContext.Lessees.FindAsync(model.LesseeId),
Owner = await _dataContext.Owners.FindAsync(model.OwnerId),
Price = model.Price,
Property = await _dataContext.Properties.FindAsync(model.PropertyId),
Remarks = model.Remarks,
StartDate = model.StartDate.ToUniversalTime(),
});
}
public ActionResult Create()
{
var initialPortfolios = portfolioRepository.GetPortfoliosByUserScope((long)Session["id"]);
initialPortfolios.ToList().ForEach(p => p.Scope = scopeRepository.GetScopeByPortfolio(p.Id) ? "Initial" : "Extent");
initialPortfolios = initialPortfolios.Where(p => p.Scope == "Initial");
var cvm = new ContractViewModel
{
Portfolios = new SelectList(initialPortfolios, dataValueField: "Id", dataTextField: "Sector"),
Zones = zoneRepository.GetAll()
};
return(View(cvm));
}
public ActionResult Edit(ContractViewModel model)
{
try
{
if (ModelState.IsValid)
{
var f = Request.Files["Document"];
if (f != null && f.ContentLength > 0)
{
string pic = System.IO.Path.GetFileName(f.FileName);//System.IO.Path.GetFileName(f.FileName);
var avatarpath = "/Uploads/Lichsuhopdongs";
string path = System.IO.Path.Combine(Server.MapPath(avatarpath), pic);
// file is uploaded
f.SaveAs(path);
using (MemoryStream ms = new MemoryStream())
{
f.InputStream.CopyTo(ms);
byte[] array = ms.GetBuffer();
}
model.Document = string.Join("/", avatarpath, pic);
}
service.Update(model);
service.Save();
return(RedirectToAction("Index", "Contract", new { employeeId = model.EmployeeId }));
}
var employees = employee.GetEmployeeSelectListItems().Select(x => new {
Id = x.Id,
Name = x.LastName + " - " + x.FirstName
}).ToList();
ViewBag.Employees = new SelectList(employees, "Id", "Name");
var contractTypes = this.contractTypeService.GetContractTypes().Select(x => new {
Id = x.Id,
Name = x.Name
});
ViewBag.ContractTypes = new SelectList(contractTypes, "Id", "Name");
return(View(model));
}
catch (Exception ex)
{
return(View(model));
}
}
public async Task <IActionResult> Create([Bind("ConstractID,Name,RoomID,CustomerID,NumOfMonth,BeginDate,EndDate,MetaTitle,Status")] ContractViewModel contract, long?priceID, int?typeID)
{
if (ModelState.IsValid)
{
_context.Add(contract);
await _context.SaveChangesAsync();
return(RedirectToAction("Index"));
}
SelectList type;
SelectList price;
if (priceID != null && priceID != 0)
{
price = new SelectList(_context.Price, "PriceID", "Price1", priceID);
}
else
{
price = new SelectList(_context.Price, "PriceID", "Price1");
}
if (typeID != null && typeID != 0)
{
if (priceID != null && priceID != 0)
{
type = new SelectList(_context.Type.Where(x => x.PriceID == priceID).OrderBy(s => s.Name), "TypeID", "Name", typeID);
}
else
{
type = new SelectList(_context.Type.OrderBy(s => s.Name), "TypeID", "Name", typeID);
}
}
else
{
if (priceID != null && priceID != 0)
{
type = new SelectList(_context.Type.Where(x => x.PriceID == priceID).OrderBy(s => s.Name), "TypeID", "Name");
}
else
{
type = new SelectList(_context.Type.OrderBy(s => s.Name), "TypeID", "Name");
}
}
ViewBag.Types = type;
ViewBag.Prices = price;
return(View(contract));
}
public void Add(ContractViewModel contact)
{
var toSave = new ContactModel()
{
CreatedDate = DateTime.Now,
Email = contact.Email,
Name = contact.Name,
Number = contact.Number,
Phone = contact.Phone,
};
var db = new DataContext();
db.Add <ContactModel>(toSave);
db.SaveChanges();
}
/// <summary>
/// 初始化单一实例应用程序对象。这是执行的创作代码的第一行，
/// 已执行，逻辑上等同于 main() 或 WinMain()。
/// </summary>
public App()
{
this.InitializeComponent();
this.Suspending += OnSuspending;
client.BaseAddress = new Uri("http://www.rowtoolong.cn:3000");
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(
new MediaTypeWithQualityHeaderValue("application/json"));
AttendanceViewModel attendanceViewModel = AttendanceViewModel.getInstance();
ContractViewModel contractViewModel = ContractViewModel.getInstance();
DepartmentChangeViewModel departmentChangeViewModel = DepartmentChangeViewModel.getInstance();
EmployeeViewModel employeeViewModel = EmployeeViewModel.getInstance();
DepartmentViewModel departmentViewModel = DepartmentViewModel.getInstance();
RewardViewModel rewardViewModel = RewardViewModel.getInstance();
TrainingViewModel trainingViewModel = TrainingViewModel.getInstance();
}
public int CreateOrUpdate(ContractViewModel item)
{
var data = (Data.Models.Contract)null;
if (item.Id > 0)
{
data = Repository.FirstOrDefault(x => x.Id == item.Id);
}
data = ToDomain(item, data);
Repository.Store(data);
Repository.SaveChanges();
return(data.Id);
}
public async Task <IActionResult> AddContract(ContractViewModel model
)
{
if (ModelState.IsValid)
{
var contract = await _converterHelper.ToContractAsync(model, true);
_dataContext.Contracts.Add(contract);
await _dataContext.SaveChangesAsync();
//return RedirectToAction($"{nameof(DetailsProperty)}/{model.PropertyId}");
return(RedirectToAction("DetailsProperty", "Owners", new { id = model.Id }));
}
return(View(model));
}
public IActionResult Delete(int id)
{
CultureInfo culture = CultureInfo.CreateSpecificCulture("uk-UA");
ContractViewModel model = context.Contracts.Select(c => new ContractViewModel
{
Id = c.Id,
DateCreate = c.DateCreate.ToString("dd.MM.yyyy", culture),
DateFinished = c.DateFinished.ToString("dd.MM.yyyy", culture),
Price = c.Price,
Consumer = c.Consumer.Name,
ConsumerImage = c.Consumer.Image,
Resource = c.Resource.Name,
ResourceUnit = c.Resource.Units,
}).SingleOrDefault(x => x.Id == id);
return(View(model));
}
public ActionResult Create()
{
var hasAccess = AuthorizationManager.HasAccess("InstagramContract.Create");
if (!hasAccess)
{
throw new Exception("شما مجاز به انجام این عملیات نیستید");
}
var model = new ContractViewModel();
model.States = GeoDivisionService.GetInstance().GetGeoDivisionByType(GeoDivisionTypes.State);
model.Customers = CustomerService.GetInstance().GetDefaultQuery().ToList();
model.Persons = PersonService.GetInstance().GetDefaultQuery().ToList();
return(View(model));
}
public void BookingTour(BookingTourCommand command)
{
var newCustomer = new Customer(command);
_db.Customers.Add(newCustomer);
_db.SaveChanges();
//Insert Contract
ContractViewModel contract = new ContractViewModel();
{
contract.CustomerId = newCustomer.Id;
contract.TourId = command.TourId;
contract.BeginDate = command.BeginDate;
contract.Paid = false;
contract.Content = command.Content;
}
var newContract = new Contract(contract);
_db.Contracts.Add(newContract);
_db.SaveChanges();
var tour = _db.Tours.FirstOrDefault(n => n.Id == command.TourId);
{
tour.Quantity = tour.Quantity - Convert.ToInt32(command.PeopleGo);
}
_db.SaveChanges();
//Insert ContractDetail
ContractDetailViewModel contractDetail = new ContractDetailViewModel();
{
contractDetail.TourId = tour.Id;
contractDetail.NameTour = tour.NameTour;
contractDetail.Cost = tour.Cost;
contractDetail.PeopleGo = Convert.ToInt32(command.PeopleGo);
contractDetail.ContractId = newContract.Id;
}
var newContractDetail = new ContractDetail();
{
newContractDetail.TourId = contractDetail.TourId;
newContractDetail.NameTour = contractDetail.NameTour;
newContractDetail.Cost = contractDetail.Cost;
newContractDetail.PeopleGo = contractDetail.PeopleGo;
newContractDetail.ContractId = contractDetail.ContractId;
}
_db.ContractDetails.Add(newContractDetail);
_db.SaveChanges();
}
public IActionResult SellCar([FromBody] ContractViewModel contract)
{
var car = _carRepository.FindCar(contract.CarNumber);
if (car is null)
{
return(StatusCode(404, "The car was not found"));
}
var client = _clientRepository.FindClient(contract.ClientPassportId);
if (client is null)
{
client = new Client
{
Name = contract.ClientName,
PasportId = contract.ClientPassportId
};
_clientRepository.AddClient(client);
}
try
{
_carRepository.SellCar(car, new Client
{
Name = contract.ClientName,
PasportId = contract.ClientPassportId
});
_contractRepository.AddContract(new Contract
{
Car = car,
Client = client,
Type = contract.Type,
TotalCost = contract.TotalCost,
FirstPayment = contract.FirstPayment,
Months = contract.Months,
MonthsPayment = contract.MonthsPayment,
CarId = car.Id,
ClientId = client.Id
});
return(Ok("Car suucessfully sold"));
}
catch (Exception ex)
{
return(StatusCode(500, "There is something wrong in the system. Please try again later :("));
}
}
public async Task <Contract> ToContractAsync(ContractViewModel model, bool isNew)
{
return(new Contract
{
//esto se aguarda con hora de londres ToUniversalTime() hora universal
EndDate = model.EndDate.ToUniversalTime(),
//estamos creando un operador ternario si es nuevo se carga 0 si no es nuevo le cargas lo que trae el modelo
Id = isNew ? 0 : model.Id,
IsActive = model.IsActive,
Lessee = await _dataContext.Lessees.FindAsync(model.LesseeId),
Owner = await _dataContext.Owners.FindAsync(model.OwnerId),
Price = model.Price,
Property = await _dataContext.Properties.FindAsync(model.PropertyId),
Remarks = model.Remarks,
StartDate = model.StartDate.ToUniversalTime()
});
}
public ActionResult Edit(int id)
{
// TODO: roles
var contract = contractLogic.GetContract(id);
var model = new ContractViewModel
{
BankAccountId = contract.BankAccountId,
BeginDate = contract.BeginDate,
Comment = contract.Comment,
ContractRoleId = contract.ContractRoleId,
ContractServiceTypeId = contract.ContractServiceTypeId,
ContractTypeId = contract.ContractTypeId,
Date = contract.Date,
EndDate = contract.EndDate,
ID = contract.ID,
IsFixed = contract.IsFixed,
IsProlongation = contract.IsProlongation,
LegalId = contract.LegalId,
Number = contract.Number,
OurBankAccountId = contract.OurBankAccountId,
OurContractRoleId = contract.OurContractRoleId,
OurLegalId = contract.OurLegalId,
PaymentTermsId = contract.PaymentTermsId,
CurrencyRateUseId = contract.CurrencyRateUseId,
PayMethodId = contract.PayMethodId,
AgentPercentage = contract.AgentPercentage,
Currencies = contractLogic.GetContractCurrencies(id)
};
model.Dictionaries.Add("User", dataLogic.GetUsers());
model.Dictionaries.Add("Legal", dataLogic.GetLegals());
model.Dictionaries.Add("OurLegal", dataLogic.GetOurLegals());
model.Dictionaries.Add("Currency", dataLogic.GetCurrencies());
model.Dictionaries.Add("PayMethod", dataLogic.GetPayMethods());
model.Dictionaries.Add("PaymentTerm", dataLogic.GetPaymentTerms());
model.Dictionaries.Add("DocumentType", dataLogic.GetDocumentTypes());
model.Dictionaries.Add("ContractType", dataLogic.GetContractTypes());
model.Dictionaries.Add("ContractRole", dataLogic.GetContractRoles());
model.Dictionaries.Add("CurrencyRateUse", dataLogic.GetCurrencyRateUses());
model.Dictionaries.Add("ContractServiceType", dataLogic.GetContractServiceTypes());
model.Dictionaries.Add("AccountingDocumentType", dataLogic.GetAccountingDocumentTypes());
return(View(model));
}
public async Task <ActionResult> Delete(string id)
{
var contract = await _contractRepository.GetByIdAsync(id);
var tenant = await _tenantRepository.GetByIdAsync(contract.TenantId);
var room = await _roomRepository.GetByIdAsync(contract.RoomId);
var accrualType = await _accrualTypeRepository.GetByIdAsync(contract.AccrualTypeId);
var vm = ContractViewModel.FromContract(contract);
vm.Tenant = tenant.Name;
vm.Room = room.Address;
vm.AccrualType = accrualType.Name;
return(View(vm));
}
public static ContractViewModel MapContractModelToContractViewModel(ContractsModel contractModel)
{
ContractViewModel contractViewModel = new ContractViewModel();
//contractViewModel.Id = contractModel.Id;
contractViewModel.DateFrom = contractModel.DateFrom;
contractViewModel.DateTo = contractModel.DateTo;
contractViewModel.ConclusionDate = contractModel.ConclusionDate;
//contractViewModel.TerminationWay = contractModel.TerminationWay.Value;
contractViewModel.TypeContract = contractModel.TypeContract.Value;
//contractViewModel.FirstName = EmployeeModel.
//contractViewModel.LastName = EmployeeModel.
return(contractViewModel);
}
private void btnCreate_Click(object sender, EventArgs e)
{
ContractAddForm frm = new ContractAddForm();
frm.ReloadContracts += (s, ea) =>
{
ContractEventArgs eventArgs = ea as ContractEventArgs;
if (eventArgs != null)
{
ContractViewModel contracts = MappingHelper.MapContractModelToContractViewModel(eventArgs.contract);
bsContracts.Add(contracts);
dgvContracts.ClearSelection();
dgvContracts.Rows[dgvContracts.Rows.Count - 1].Selected = true;
}
};
frm.ShowDialog();
}
public ActionResult Edit(long id)
{
var contract = contractRepository.GetById(id);
var zonesIds = new List <long>();
contract.Zones.ToList().ForEach(z => zonesIds.Add(z.Id));
var cvm = new ContractViewModel
{
Portfolios = new SelectList(portfolioRepository.GetAll(), dataValueField: "Id", dataTextField: "Sector"),
Contract = contract,
Zones = zoneRepository.GetAll(),
ZonesIds = zonesIds
};
return(View(cvm));
}
public IActionResult Submit([FromBody] ContractViewModel model)
{
IActionResult response;
if (_contract.IsSubmit(model.Id))
{
response = BadRequest(UtilityService.InitialResultError(MessageValue.ContractStatusSubmit, (int)System.Net.HttpStatusCode.BadRequest));
}
if (_contract.IsNotNull(model.Id))
{
response = Ok(_contract.Edit(model, ConstantValue.ContractStatusSaveSubmit));
}
else
{
response = Ok(_contract.Save(model, ConstantValue.ContractStatusSaveSubmit));
}
return(response);
}
public async Task <ActionResult> Edit(ContractViewModel contract)
{
if (!ModelState.IsValid)
{
return(View(contract));
}
try
{
await _contractRepository.UpdateAsync(ContractViewModel.FromContractViewModel(contract));
return(RedirectToAction(nameof(Index)));
}
catch
{
return(View(contract));
}
}
