public static IList <NormaContent> reorderNormaContents(IList <NormaContent> normaContents, bool isWinter)
{
List <NormaContent> nc = new List <NormaContent>(normaContents);
nc.Sort();
normaContents = nc;
NormaContent item = null;
for (int i = 0, j = 0; j < normaContents.Count; i++)
{
item = normaContents[i];
if (item.IsActive == false)
{
normaContents.Remove(item);
i--;
continue;
}
if (item.InShop || (isWinter == false && item.NomGroup.IsWinter))
{
normaContents.Remove(item);
i--;
continue;
}
if (item.NomGroup.NomBodyPart.Id == DataGlobals.SIZ_SIZE_ID)
{
normaContents.Remove(item);
normaContents.Add(item);
i--;
}
j++;
}
return(normaContents);
}
public static NormaContent rebuildNormaContent(NormaContent inNormaContent)
{
NormaContent normaContent = new NormaContent(inNormaContent.Id, inNormaContent.Quantity, inNormaContent.UsePeriod);
normaContent.NormaId = inNormaContent.NormaId;
normaContent.IsActive = inNormaContent.IsActive;
// if (inNormaContent.QuantityTON != 0)
normaContent.QuantityTON = inNormaContent.QuantityTON;
// else
// normaContent.QuantityTON = inNormaContent.Quantity;
NomGroup nomGroup = rebuildNomGroup(inNormaContent.NomGroup);
normaContent.NomGroup = nomGroup;
normaContent.InShop = inNormaContent.InShop;
List <NormaNomGroup> normaNomGroups = new List <NormaNomGroup>();
foreach (var item in inNormaContent.NormaNomGroups)
{
NormaNomGroup normaNomGroup = rebuildNormaNomGroup(item);
normaNomGroups.Add(normaNomGroup);
}
normaContent.NormaNomGroups = normaNomGroups;
string normaContentInfo = "";
foreach (var item in normaContent.NormaNomGroups)
{
if (item.IsBase == false)
{
normaContentInfo = normaContentInfo + item.NomGroup.Name + "; ";
}
}
normaContent.NormaContentInfo = normaContentInfo;
return(normaContent);
}
public ActionResult Delete()
{
string idOrg = getCurrentEnterpriseId();
string shopNumber = Session["shopNumber"].ToString();
int idOrganization = System.Int32.Parse(idOrg);
Organization organization = organizationRepository.Get(idOrganization);
IList <WorkerCardContent> workerCardContents = null;
Norma norma = new Norma();
if (TryUpdateModel <Norma>(norma))
{
Dictionary <string, object> queryParams = new Dictionary <string, object>();
norma = normaRepository.Get(norma.Id);
queryParams.Clear();
queryParams.Add("Norma.Id", norma.Id);
string flag = "";
IEnumerable <NormaOrganization> workplaces = normaOrganizationRepository.FindAll(queryParams);
foreach (var workplace in workplaces)
{
normaOrganizationRepository.Delete(workplace);
}
NormaContent normaContent = null;
for (int i = 0; i < norma.NormaContents.Count; i++)
{
normaContent = norma.NormaContents[i];
queryParams.Clear();
queryParams.Add("NormaContent", normaContent);
workerCardContents = workerCardContentRepository.GetByLikeCriteria(queryParams);
if (workerCardContents.Count > 0)
{
flag = "1";
normaContent.IsActive = false;
}
else
{
norma.NormaContents.Remove(normaContent);
normaContentRepository.Delete(normaContent);
i--;
}
}
if (flag == "1")
{
//normaContents = newNormaContents;
//norma.NormaContents = normaContents;
norma.Organization = organization;
norma.IsActive = false;
normaRepository.SaveOrUpdate(norma);
}
else
{
normaRepository.Delete(norma);
}
}
//HttpContext.Cache.Remove("NormaId");
Session.Remove("NormaId");
return(_SelectionClientSide_Normas(shopNumber, Session["shopInfo"].ToString()));
}
public void ChangeContentDel(NormaContent normaContent)
{
Dictionary <string, object> queryParams = new Dictionary <string, object>();
queryParams.Add("NormaId", normaContent.NormaId);
queryParams.Add("IsActive", true);
IList <NormaContent> normaContents = normaContentRepository.FindAll(queryParams);
foreach (var item in normaContents)
{
foreach (var nng in item.NormaNomGroups)
{
queryParams.Clear();
queryParams.Add("NormaContent.Id", normaContent.Id);
IList <WorkerCardContent> workerCardContents = workerCardContentRepository.FindAll(queryParams);
foreach (var wcc in workerCardContents)
{
if (wcc.Storage.Nomenclature.NomGroup.Id == nng.NomGroup.Id)
{
wcc.NormaContent = nng.NormaContent;
workerCardContentRepository.SaveOrUpdate(wcc);
}
}
}
}
}
public ActionResult SaveNormaNomGroup(string id)
{
string NormaContentId = null;
if (Session["NormaContentId"] != null)
{
NormaContentId = Session["NormaContentId"].ToString();
}
// NormaNomGroup normaNomGroup = new NormaNomGroup();
NormaNomGroup newNormaNomGroup = normaNomGroupRepository.Get(int.Parse(id));
NormaNomGroup normaNomGroup = new NormaNomGroup();
normaNomGroup.NomGroup = newNormaNomGroup.NomGroup;
NormaContent normaContent = normaContentRepository.Get(int.Parse(NormaContentId));
if (TryUpdateModel <NormaNomGroup>(normaNomGroup, null, new string[] { "NomGroup" }, new string[] { "NormaContent" }))
{
if (normaNomGroup.NomGroup.Id != newNormaNomGroup.NomGroup.Id)
{
ValidateNormaNomGroup(normaContent.Id, normaNomGroup);
}
if (ModelState.IsValid)
{
newNormaNomGroup.NormaContent = normaContent;
newNormaNomGroup.NomGroup = normaNomGroup.NomGroup;
normaNomGroupRepository.SaveOrUpdate(newNormaNomGroup);
ChangeContentIns(newNormaNomGroup);
}
}
return(_Selection_NormaNomGroups(NormaContentId));
}
public ActionResult InsertContent()
{
int NormaId = int.Parse(Session["NormaId"].ToString());
NormaContent normaContent = new NormaContent();
IList <NormaNomGroup> normaNomGroups = new List <NormaNomGroup>();
TryUpdateModel(normaContent);
{
ValidateContent(NormaId, normaContent, true);
if (ModelState.IsValid)
{
normaContent.NormaId = NormaId;
NormaNomGroup normaNomGroup = new NormaNomGroup();
normaNomGroup.NomGroup = normaContent.NomGroup;
normaNomGroup.IsBase = true;
normaNomGroup.NormaContent = normaContent;
normaNomGroups.Add(normaNomGroup);
normaContent.NormaNomGroups = normaNomGroups;
normaContent.IsActive = true;
normaContentRepository.SaveOrUpdate(normaContent);
ChangeContentIns(normaNomGroup);
}
}
return(_SelectionClientSide_NormaContents(NormaId.ToString()));
}
public void ValidateContent(int NormaId, NormaContent normaContent, bool isControlNomgroup)
{
if (isControlNomgroup == true)
{
Dictionary <string, object> queryParams = new Dictionary <string, object>();
queryParams.Add("NormaId", NormaId);
queryParams.Add("IsActive", true);
IList <NormaContent> normaContents = normaContentRepository.FindAll(queryParams);
foreach (var item in normaContents)
{
foreach (var nng in item.NormaNomGroups)
{
if (nng.NomGroup.Id == normaContent.NomGroup.Id)
{
ModelState.AddModelError("NomGroup", "Группа " + normaContent.NomGroup.Name + " уже добавлена в норму");
}
}
}
}
if (normaContent.Quantity == 0)
{
ModelState.AddModelError("Quantity", "Количество не может быть 0");
}
if (normaContent.InShop == false && normaContent.UsePeriod == 0)
{
ModelState.AddModelError("UsePeriod ", "Период использования для СИЗ, выдаваемых в салоне, не должен быть 0");
}
}
public static NormaNomGroup rebuildNormaNomGroup(NormaNomGroup inNormaNomGroup)
{
NormaNomGroup normaNomGroup = new NormaNomGroup(inNormaNomGroup.Id);
normaNomGroup.NomGroup = rebuildNomGroup(inNormaNomGroup.NomGroup);
normaNomGroup.IsBase = inNormaNomGroup.IsBase;
NormaContent nc = new NormaContent(inNormaNomGroup.NormaContent.Id);
normaNomGroup.NormaContent = nc;
return(normaNomGroup);
}
private Storage getStorageForWorkerNorma(NormaContent normaContent, Worker worker)
//private Storage getStorageForWorkerNorma(NormaContent normaContent, IList<NomBodyPartSize> NomBodyPartSizes)
{
//Storage storage = null;
List <Storage> storages = null;
NomBodyPart normaBodyPart = normaContent.NomGroup.NomBodyPart;
NomBodyPartSize workerBodyPartSize = null;
foreach (var item in worker.NomBodyPartSizes)
//foreach (var item in NomBodyPartSizes)
{
if (item.NomBodyPart.Id == normaBodyPart.Id)
{
workerBodyPartSize = item;
break;
}
}
Dictionary <string, object> query = new Dictionary <string, object>();
query.Add("StorageName.Organization.Id", int.Parse(getCurrentEnterpriseId()));
query.Add("Nomenclature.NomGroup.Id", normaContent.NomGroup.Id);
query.Add("NomBodyPartSize.NomBodyPart.Id", normaBodyPart.Id);
if (workerBodyPartSize != null && DataGlobals.SIZ_SIZE_ID != normaBodyPart.Id)
{
query.Add("NomBodyPartSize.SizeNumber", workerBodyPartSize.SizeNumber);
}
if (DataGlobals.CLOTH_SIZE_ID == normaBodyPart.Id)
{
query.Add("Growth.SizeNumber", worker.Growth);
}
storages = (List <Storage>)storageRepository.GetByCriteria(query);
if (storages == null || storages.Count == 0)
{
query.Clear();
query.Add("StorageName.Organization.Id", int.Parse(getCurrentEnterpriseId()));
foreach (var normaNomGroup in normaContent.NormaNomGroups)
{
query.Add("Nomenclature.NomGroup.Id", normaNomGroup.NomGroup.Id);
storages.AddRange(storageRepository.GetByLikeCriteria(query));
query.Remove("Nomenclature.NomGroup.Id");
}
}
if (storages == null || storages.Count == 0)
{
storages.Add(new Storage());
}
return(storages[0]);
}
public ActionResult Copy(string Id)
{
Norma norma = normaRepository.Get(int.Parse(Id));
Norma newNorma = new Norma();
newNorma.Organization = norma.Organization;
newNorma.Name = norma.Name + " (Копия)";
newNorma.IsActive = norma.IsActive;
newNorma.NormaComment = norma.NormaComment;
normaRepository.SaveOrUpdate(newNorma);
Dictionary <string, object> queryParams = new Dictionary <string, object>();
queryParams.Add("NormaId", int.Parse(Id));
queryParams.Add("IsActive", true);
Dictionary <string, object> orderParams = new Dictionary <string, object>();
orderParams.Add("Id", ASC);
IEnumerable <NormaContent> normaContents = normaContentRepository.GetByCriteria(queryParams, orderParams);
foreach (var item in normaContents)
{
NormaContent nc = new NormaContent();
nc.Quantity = item.Quantity;
nc.QuantityTON = item.QuantityTON;
nc.UsePeriod = item.UsePeriod;
nc.IsActive = item.IsActive;
nc.NormaId = newNorma.Id;
nc.NomGroup = item.NomGroup;
nc.InShop = item.InShop;
normaContentRepository.SaveOrUpdate(nc);
foreach (var nng in item.NormaNomGroups)
{
NomGroup nomGroup = new NomGroup(nng.NomGroup.Id, nng.NomGroup.Name);
NomBodyPart nb = new NomBodyPart(nng.NomGroup.NomBodyPart.Id, nng.NomGroup.NomBodyPart.Name);
Organization o = rebuildOrganization(nng.NomGroup.Organization);
nomGroup.Organization = o;
nomGroup.NomBodyPart = nb;
NormaNomGroup ng = new NormaNomGroup();
ng.NomGroup = nomGroup;
ng.IsBase = nng.IsBase;
ng.NormaContent = nc;
normaNomGroupRepository.SaveOrUpdate(ng);
}
}
;
return(View(viewName));
// return _SelectionClientSide_Normas();
}
public ActionResult SaveContent(string Id)
{
Dictionary <string, object> queryParams = new Dictionary <string, object>();
queryParams.Add("Id", int.Parse(Id));
NormaContent newNormaContent = normaContentRepository.FindOne(queryParams);
IList <NormaNomGroup> newNormaNomGroups = new List <NormaNomGroup>();
NormaContent normaContent = new NormaContent();
newNormaNomGroups = newNormaContent.NormaNomGroups;
if (TryUpdateModel <NormaContent>(normaContent, null, new string[] { "NomGroup", "Quantity", "UsePeriod", "InShop", "IsActive", "QuantityTON" }, new string[] { "NormaNomGroups" }))
{
if (newNormaContent.NomGroup.Id == normaContent.NomGroup.Id)
{
ValidateContent(newNormaContent.NormaId, normaContent, false);
}
else
{
ValidateContent(newNormaContent.NormaId, normaContent, true);
}
if (ModelState.IsValid)
{
foreach (NormaNomGroup nng in newNormaNomGroups)
{
if (nng.IsBase)
{
newNormaNomGroups[newNormaNomGroups.IndexOf(nng)].NomGroup = normaContent.NomGroup;
}
}
newNormaContent.NomGroup = normaContent.NomGroup;
newNormaContent.Quantity = normaContent.Quantity;
newNormaContent.UsePeriod = normaContent.UsePeriod;
newNormaContent.IsActive = normaContent.IsActive;
newNormaContent.InShop = normaContent.InShop;
newNormaContent.QuantityTON = normaContent.QuantityTON;
normaContentRepository.SaveOrUpdate(newNormaContent);
//ChangeContentIns(newNormaContent.NomGroup);
}
}
return(_SelectionClientSide_NormaContents(newNormaContent.NormaId.ToString()));
}
public ActionResult _SelectionClientSide_NormaContents(string id)
{
Dictionary <string, object> queryParams = new Dictionary <string, object>();
List <NormaContent> model = new List <NormaContent>();
int idNorma = 0;
if (id == null)
{
if (Session["NormaId"] != null)
{
idNorma = int.Parse(Session["NormaId"].ToString());
}
}
else
{
idNorma = int.Parse(id);
}
if (idNorma != 0)
{
Norma norma = normaRepository.Get(idNorma);
Session.Add("NormaId", idNorma);
queryParams.Add("NormaId", idNorma);
queryParams.Add("IsActive", true);
Dictionary <string, object> orderParams = new Dictionary <string, object>();
orderParams.Add("NomGroup.IsWinter", ASC);
orderParams.Add("NomGroup.NomBodyPart.Id", ASC);
orderParams.Add("NomGroup.Name", ASC);
IEnumerable <NormaContent> normaContents = normaContentRepository.GetByLikeCriteria(queryParams, orderParams);
foreach (var item in normaContents)
{
NormaContent nc = rebuildNormaContent(item);
nc.IsApproved = norma.IsApproved;
model.Add(nc);
}
}
return(View(new GridModel <NormaContent>
{
Data = model
}));
}
public ActionResult DeleteContent(int Id)
{
NormaContent normaContent = normaContentRepository.Get(Id);
Dictionary <string, object> queryParams = new Dictionary <string, object>();
queryParams.Add("NormaContent", normaContent);
IList <WorkerCardContent> workerCardContents = workerCardContentRepository.FindAll(queryParams);
if (workerCardContents.Count == 0)
{
normaContentRepository.Delete(normaContent);
}
else
{
normaContent.IsActive = false;
normaContentRepository.SaveOrUpdate(normaContent);
}
ChangeContentDel(normaContent);
return(_SelectionClientSide_NormaContents(normaContent.NormaId.ToString()));
}
public ActionResult _GetNomenclaturesOnStorage(string normaContentId, string text)
{
Dictionary <string, object> queryParams = new Dictionary <string, object>();
List <Storage> storages = new List <Storage>();
int code = -1;
if (int.TryParse(text, out code))
{
queryParams.Add("Nomenclature.ExternalCode", text);
}
else
{
queryParams.Add("Nomenclature.Name", text);
}
queryParams.Add("StorageName.Organization.Id", int.Parse(getCurrentEnterpriseId()));
if (normaContentId != null)
{
NormaContent normaContent = normaContentRepository.Get(int.Parse(normaContentId));
foreach (var normaNomGroup in normaContent.NormaNomGroups)
{
queryParams.Add("Nomenclature.NomGroup.Id", normaNomGroup.NomGroup.Id);
storages.AddRange(storageRepository.GetByLikeCriteria(queryParams));
queryParams.Remove("Nomenclature.NomGroup.Id");
}
}
else
{
storages.AddRange(storageRepository.GetByLikeCriteria(queryParams));
}
return(new JsonResult
{
Data = new SelectList(storages, "Id", "StorageInfo")
});
}
public void ValidateNormaNomGroup(int NormaContentId, NormaNomGroup normaNomGroup)
{
NormaContent normaContent = normaContentRepository.Get(NormaContentId);
Dictionary <string, object> queryParams = new Dictionary <string, object>();
queryParams.Add("NormaId", normaContent.NormaId);
queryParams.Add("IsActive", true);
IList <NormaContent> normaContents = normaContentRepository.FindAll(queryParams);
foreach (var nc in normaContents)
{
queryParams.Clear();
queryParams.Add("NormaContent", nc);
IList <NormaNomGroup> normaNomGroups = normaNomGroupRepository.FindAll(queryParams);
foreach (var nng in normaNomGroups)
{
if (nng.NomGroup.Id == normaNomGroup.NomGroup.Id)
{
ModelState.AddModelError(nng.NomGroup.Id.ToString(), "Группа " + normaNomGroup.NomGroup.Name + " уже добавлена в норму");
}
}
}
}
public ActionResult _TransferWorkerCard(int?workerWorkplaceId, int storageNameId, string listId, Boolean outNorma, string OperDate)
{
DateTime operDate;
DateTime.TryParseExact(OperDate, DataGlobals.DATE_FORMAT, null, System.Globalization.DateTimeStyles.None, out operDate);
ResultState resultState = new ResultState();
resultState.Status = ResultState.OK;
if (workerWorkplaceId != null)
{
Dictionary <string, object> query = new Dictionary <string, object>();
Dictionary <string, object> order = new Dictionary <string, object>();
query.Add("Worker.Id", workerWorkplaceId);
query.Add("IsActive", true);
order.Add("Storage.StorageName.Id", storageNameId);
//Выбираем активные рабочие места
IList <WorkerWorkplace> workerWorkplaces = workerWorkplaceRepository.GetByLikeCriteria(query);
if (workerWorkplaces.Count == 1)
{
WorkerWorkplace ww = workerWorkplaces[0];
//Выбираем активные рабочие места
// Запрет на одевание работника в салоне к которому он не приписан. Пока закомментировала, т.к. не уверена, что не будет последствий
/*
* if (ww.Organization.StorageName.Id != storageNameId)
* {
* resultState.Status = ResultState.ERROR;
* resultState.setMessage("НЕЛЬЗЯ ВЫПОЛНИТЬ ПЕРЕВОД!!! Работник приписан к складу " + ww.Organization.StorageName.StorageNumber);
* }
*/
string periodDateStr = getConfigParamValue(configRepository, "periodDate", getCurrentEnterpriseId());
string periodIsClosed = getConfigParamValue(configRepository, "periodIsClosed", getCurrentEnterpriseId());
DateTime periodDate;
DateTime.TryParseExact(periodDateStr, DataGlobals.DATE_FORMAT_FULL_YEAR, null, System.Globalization.DateTimeStyles.None, out periodDate);
// проверка на закрытие периода
if (periodIsClosed != null && periodIsClosed.Equals("1") && periodDate > operDate)
{
resultState.Status = ResultState.ERROR;
resultState.setMessage(OperDate + ": Период закрыт для изменений");
}
if (resultState.Status == ResultState.OK)
{
query.Clear();
query.Add("WorkerWorkplace", ww);
WorkerCardHead newWorkerCardHead = workerCardRepository.FindOne(query);
if (newWorkerCardHead == null)
{
newWorkerCardHead = new WorkerCardHead();
newWorkerCardHead.WorkerWorkplace = ww;
}
query.Clear();
query.Add("Organization", ww.Organization);
query.Add("Norma.Organization.Id", int.Parse(getCurrentEnterpriseId()));
query.Add("Norma.IsActive", true);
IList <NormaOrganization> normaOrganizations = normaOrganizationRepository.GetByCriteria(query);
IList <NomenclatureSimple> list = getNomenclaturesByParam(listId);
string docNumber = "00000";
// Убрала ниже, чтобы можно было изменять номер документа
docNumber = operationRepository.GetNextDocNumber(DataGlobals.OPERATION_STORAGE_TRANSFER_OUT, getCurrentEnterpriseId());
int?skladId = null;
foreach (var item in list)
{
ResultState listResultState = new ResultState();
listResultState.Status = ResultState.OK;
WorkerCardContent oldWorkerCardContent = workerCardContentRepository.Get(item.Id);
if (skladId != null && skladId != oldWorkerCardContent.Storage.StorageName.Id)
{
docNumber = operationRepository.GetNextDocNumber(DataGlobals.OPERATION_STORAGE_TRANSFER_OUT, getCurrentEnterpriseId());
}
if (oldWorkerCardContent.StartDate >= operDate)
{
listResultState.Status = ResultState.ERROR;
listResultState.setMessage(item.Name + " Дата перевода раньше даты выдачи!!! Введите текущую дату!");
resultState.Status = ResultState.ERROR;
resultState.setMessage(item.Name + " Дата перевода раньше даты выдачи!!! Введите текущую дату!");
}
NormaContent newNormaContent = GetNewNormaContent(normaOrganizations, item.GroupId);
// Если на новом рабочем месте номенклатура не подходит по норме и выбрана опция
//Ставим старую норму
//Закомментировано, т.к. по просьбе УПУ не нужно переносить на руки, то что не по норме
if (newNormaContent == null && outNorma == true)
{
newNormaContent = oldWorkerCardContent.NormaContent;
}
// if (newNormaContent != null )
if (newNormaContent == null && outNorma != true)
{
listResultState.Status = ResultState.ERROR;
listResultState.setMessage(item.Name + " НЕ СООТВЕТСТВУЕТ новой норме. Выполните ВОЗВРАТ или СПИСАНИЕ по акту!");
resultState.Status = ResultState.ERROR;
resultState.setMessage(item.Name + " НЕ СООТВЕТСТВУЕТ новой норме. Выполните ВОЗВРАТ или СПИСАНИЕ по акту!");
}
else
{
Storage storageTo = null;
//Выбранный склад и склад номенклатуры совпадают
if (oldWorkerCardContent.Storage.StorageName.Id == storageNameId)
{
storageTo = oldWorkerCardContent.Storage;
}
//Выбранный склад и склад номенклатуры не совпадают
else
{
//Пытаемся найти номенклатуру на другом складе
StorageName storageName = storageNameRepository.Get(storageNameId);
if (storageName == null)
{
listResultState.Status = ResultState.ERROR;
listResultState.setMessage("В справочнике не найден склад с идентификатором " + storageNameId + "!");
resultState.Status = ResultState.ERROR;
resultState.setMessage("В справочнике не найден склад с идентификатором " + storageNameId + "!");
}
if (listResultState.Status == ResultState.OK)
{
query.Clear();
query.Add("Nomenclature", oldWorkerCardContent.Storage.Nomenclature);
query.Add("StorageName", storageName);
if (oldWorkerCardContent.Storage.Wear == null)
{
query.Add("[]Wear", "");
}
else
{
query.Add("Wear", oldWorkerCardContent.Storage.Wear);
}
if (oldWorkerCardContent.Storage.Growth == null)
{
query.Add("[]Growth", "");
}
else
{
query.Add("Growth", oldWorkerCardContent.Storage.Growth);
}
if (oldWorkerCardContent.Storage.NomBodyPartSize == null)
{
query.Add("[]NomBodyPartSize", "");
}
else
{
query.Add("NomBodyPartSize", oldWorkerCardContent.Storage.NomBodyPartSize);
}
IList <Storage> storages = storageRepository.GetByLikeCriteria(query);
if (storages.Count > 0)
{
storageTo = storages[0];
}
else
{
//На новом складе не нашлась номенклатура
storageTo = new Storage();
storageTo.StorageName = storageName;
storageTo.Nomenclature = oldWorkerCardContent.Storage.Nomenclature;
storageTo.Quantity = 0;
storageTo.Price = oldWorkerCardContent.Storage.Price;
storageTo.Growth = oldWorkerCardContent.Storage.Growth;
storageTo.NomBodyPartSize = oldWorkerCardContent.Storage.NomBodyPartSize;
storageTo.Wear = oldWorkerCardContent.Storage.Wear;
storageRepository.SaveOrUpdate(storageTo);
}
}
}
// if (resultState.Status == ResultState.OK)
if (listResultState.Status == ResultState.OK)
{
//Создаем операцию на перевод по старому месту работы
Operation oldOperation = new Operation();
oldOperation.WorkerWorkplace = oldWorkerCardContent.WorkerCardHead.WorkerWorkplace;
oldOperation.OperDate = operDate; //DateTime.Now;
oldOperation.Quantity = oldWorkerCardContent.Quantity;
oldOperation.OperType = operTypeRepository.Get(DataGlobals.OPERATION_STORAGE_TRANSFER_OUT);
oldOperation.Organization = organizationRepository.Get(int.Parse(getCurrentEnterpriseId()));
oldOperation.DocNumber = docNumber;
oldOperation.GiveOperation = oldWorkerCardContent.GiveOperation;
//oldOperation.DocDate=
query.Clear();
query.Add("OperType", oldOperation.OperType);
IList <Motiv> motivs = motivRepository.GetByLikeCriteria(query);
if (motivs.Count > 0)
{
oldOperation.Motiv = motivs[0];
}
oldOperation.Storage = oldWorkerCardContent.Storage;
//Создаем операцию на перевод по новому месту работы
Operation newOperation = new Operation();
newOperation.WorkerWorkplace = ww;
newOperation.OperDate = operDate; //DateTime.Now;
newOperation.Quantity = oldWorkerCardContent.Quantity;
newOperation.OperType = operTypeRepository.Get(DataGlobals.OPERATION_STORAGE_TRANSFER_IN);
newOperation.Organization = organizationRepository.Get(int.Parse(getCurrentEnterpriseId()));
newOperation.DocNumber = docNumber;
newOperation.GiveOperation = oldWorkerCardContent.GiveOperation;
//newOperation.DocDate=
motivs.Clear();
query.Clear();
query.Add("OperType", newOperation.OperType);
motivs = motivRepository.GetByLikeCriteria(query);
if (motivs.Count > 0)
{
newOperation.Motiv = motivs[0];
}
newOperation.Storage = storageTo;
newOperation.TransferOperation = oldOperation;
oldOperation.TransferOperation = newOperation;
operationRepository.SaveOrUpdate(oldOperation);
operationRepository.SaveOrUpdate(newOperation);
//Создаем новую карточку
WorkerCardContent newWorkerCardContent = new WorkerCardContent();
newWorkerCardContent.WorkerCardHead = newWorkerCardHead;
newWorkerCardContent.Storage = storageTo;
newWorkerCardContent.Quantity = oldWorkerCardContent.Quantity;
newWorkerCardContent.Operation = newOperation;
newWorkerCardContent.StartDate = oldWorkerCardContent.StartDate;
newWorkerCardContent.UsePeriod = oldWorkerCardContent.UsePeriod;
newWorkerCardContent.GiveOperation = oldWorkerCardContent.GiveOperation;
//Проставляем новую норму!!!
newWorkerCardContent.NormaContent = newNormaContent;
//Обнуляем старую карточку
oldWorkerCardContent.Quantity = 0;
oldWorkerCardContent.EndDate = operDate; //DateTime.Now;
oldWorkerCardContent.OperReturn = oldOperation;
//Сохраняем новую и старую карточки
workerCardContentRepository.SaveOrUpdate(oldWorkerCardContent);
workerCardContentRepository.SaveOrUpdate(newWorkerCardContent);
}
}
skladId = oldWorkerCardContent.Storage.StorageName.Id;
}
}
}
else
{
//У человека несколько активных рабочих мест или рабочее место не найдено
resultState.Status = ResultState.ERROR;
resultState.setMessage("У человека больше одного рабочего места или рабочее место не найдено!");
}
}
return(Json(resultState));
}
