public ActionResult Create(CreateFormModel createFormModel)
{
RequestResult requestResult = new RequestResult();
try
{
var model = Session["OrganizationCreateFormModel"] as CreateFormModel;
model.FormInput = createFormModel.FormInput;
requestResult = OrganizationDataAccessor.Create(model);
if (requestResult.IsSuccess)
{
HttpRuntime.Cache.Remove("Organizations");
Session.Remove("OrganizationFormAction");
Session.Remove("OrganizationCreateFormModel");
var account = Session["Account"] as Account;
account.OrganizationPermissions = OrganizationDataAccessor.GetOrganizationPermissions(account.OrganizationId);
Session["Account"] = account;
}
}
catch (Exception e)
{
var error = new Error(MethodBase.GetCurrentMethod(), e);
Logger.Log(error);
requestResult.ReturnError(error);
//throw;
}
return(Content(JsonConvert.SerializeObject(requestResult)));
}
public ActionResult InitEditableOrganizationSelectTree(Guid editableAncestorOrganizationId, Guid ancestorOrganizationId)
{
try
{
var organizationList = HttpRuntime.Cache.GetOrInsert("Organizations", () => OrganizationDataAccessor.GetAllOrganizations());
RequestResult result = OrganizationDataAccessor.GetEditableOrganizationRootTreeItem(organizationList, editableAncestorOrganizationId, ancestorOrganizationId, Session["Account"] as Account);
if (result.IsSuccess)
{
return(PartialView("_EditableOrganizationSelectTree", JsonConvert.SerializeObject((List <TreeItem>)result.Data)));
}
else
{
return(PartialView("_Error", result.Error));
}
}
catch (Exception ex)
{
var err = new Error(MethodBase.GetCurrentMethod(), ex);
Logger.Log(err);
return(PartialView("_Error", err));
}
}
public ActionResult GetEditableOrganizationSelectTreeItem(Guid editableAncestorOrganizationId, Guid organizationId)
{
string jsonTree = string.Empty;
try
{
var organizationList = HttpRuntime.Cache.GetOrInsert("Organizations", () => OrganizationDataAccessor.GetAllOrganizations());
RequestResult result = OrganizationDataAccessor.GetEditableOrganizationTreeItem(organizationList, editableAncestorOrganizationId, organizationId, Session["Account"] as Account);
if (result.IsSuccess)
{
jsonTree = JsonConvert.SerializeObject((List <TreeItem>)result.Data);
}
else
{
jsonTree = string.Empty;
}
}
catch (Exception ex)
{
jsonTree = string.Empty;
Logger.Log(MethodBase.GetCurrentMethod(), ex);
}
return(Content(jsonTree));
}
public static RequestResult GetDetailViewModel(string abnormalReasonId, Account account)
{
RequestResult result = new RequestResult();
try
{
using (CFContext context = new CFContext())
{
var abnormalReason = context.AbnormalReasons.Include("Solutions").First(x => x.AbnormalReasonId == new Guid(abnormalReasonId));
result.ReturnData(new DetailViewModel()
{
AbnormalReasonId = abnormalReason.AbnormalReasonId.ToString(),
Permission = account.OrganizationPermission(abnormalReason.OrganizationId),
OrganizationId = abnormalReason.OrganizationId.ToString(),
ParentOrganizationFullName = OrganizationDataAccessor.GetOrganizationFullName(abnormalReason.OrganizationId),
Type = abnormalReason.Type,
ARId = abnormalReason.ARId,
Name = abnormalReason.Name,
SolutionNames = abnormalReason.Solutions.Select(x => x.Name).ToList()
});
}
}
catch (Exception ex)
{
var err = new Error(MethodBase.GetCurrentMethod(), ex);
Logger.Log(err);
result.ReturnError(err);
}
return(result);
}
public void organizationByName()
{
OrganizationDataAccessor dalOrganization = new OrganizationDataAccessor();
DataSet1 dataSet1 = new DataSet1();
AbstractConnection connection = null;
AbstractTransaction transaction = null;
try
{
connection = DBFactory.createConnection();
connection.open();
transaction = connection.beginTransaction();
dalOrganization.Read(connection, transaction, dataSet1);
transaction.commit();
}
catch (Exception e)
{
transaction.rollback();
}
finally
{
connection.close();
}
List <DataRow> list = dataSet1.organization.Select("organization_name = 'ОАО \"КРАСНОЯРСКЛЕСОМАТЕРИАЛЫ\"'").OfType <DataRow>().ToList();
Assert.That(list.Count, Is.EqualTo(1));
Assert.That((int)(list[0]["id"]), Is.EqualTo(2));
Assert.That((string)(list[0]["organization_name"]), Is.EqualTo("ОАО \"КРАСНОЯРСКЛЕСОМАТЕРИАЛЫ\""));
Assert.That((int)(list[0]["okpo_number"]), Is.EqualTo(47828137));
}
public static RequestResult GetDetailViewModel(string solutionId, Account account)
{
RequestResult result = new RequestResult();
try
{
using (CFContext context = new CFContext())
{
var solution = context.Solutions.First(x => x.SolutionId == new Guid(solutionId));
result.ReturnData(new DetailViewModel()
{
SolutionId = solution.SolutionId.ToString(),
Permission = account.OrganizationPermission(solution.OrganizationId),
OrganizationId = solution.OrganizationId.ToString(),
ParentOrganizationFullName = OrganizationDataAccessor.GetOrganizationFullName(solution.OrganizationId),
SolutionType = solution.Type,
SId = solution.SId,
Name = solution.Name
});
}
}
catch (Exception ex)
{
var err = new Error(MethodBase.GetCurrentMethod(), ex);
Logger.Log(err);
result.ReturnError(err);
}
return(result);
}
public ActionResult Edit(string organizationId)
{
try
{
RequestResult requestResult = new RequestResult();
requestResult = OrganizationDataAccessor.GetEditFormModel(new Guid(organizationId));
if (requestResult.IsSuccess)
{
Session["OrganizationFormAction"] = Define.EnumFormAction.Edit;
Session["OrganizationEditFormModel"] = requestResult.Data;
return(PartialView("_Edit", Session["OrganizationEditFormModel"]));
}
else
{
return(PartialView("_Error", requestResult.Error));
}
}
catch (Exception e)
{
var error = new Error(MethodBase.GetCurrentMethod(), e);
Logger.Log(error);
return(PartialView("_Error", error));
//throw;
}
}
public static RequestResult GetCopyFormModel(string abnormalReasonId)
{
RequestResult result = new RequestResult();
try
{
using (CFContext context = new CFContext())
{
var abnormalReason = context.AbnormalReasons.Include("Solutions").First(x => x.AbnormalReasonId == new Guid(abnormalReasonId));
var model = new CreateFormModel()
{
OrganizationId = abnormalReason.OrganizationId.ToString(),
ParentOrganizationFullName = OrganizationDataAccessor.GetOrganizationFullName(abnormalReason.OrganizationId),
Types = new List <SelectListItem>()
{
Define.DefaultSelectListItem(Resources.Resource.Select),
new SelectListItem()
{
Text = Resources.Resource.Create + "...",
Value = Define.New
}
},
SolutionModels = abnormalReason.Solutions.Select(x => new SolutionModel
{
SolutionId = x.SolutionId.ToString(),
Type = x.Type,
SId = x.SId,
Name = x.Name,
}).OrderBy(x => x.Type).ThenBy(x => x.SId).ToList(),
FormInput = new FormInput()
{
Type = abnormalReason.Type
}
};
var upStreamOrganizationIds = OrganizationDataAccessor.GetUpStreamOrganizationIds(abnormalReason.OrganizationId, true);
model.Types.AddRange(context.AbnormalReasons.Where(x => upStreamOrganizationIds.Contains(x.OrganizationId)).Select(x => x.Type).Distinct().OrderBy(x => x).Select(x => new SelectListItem
{
Value = x,
Text = x
}).ToList());
model.Types.First(x => x.Value == abnormalReason.Type).Selected = true;
result.ReturnData(model);
}
}
catch (Exception ex)
{
var err = new Error(MethodBase.GetCurrentMethod(), ex);
Logger.Log(err);
result.ReturnError(err);
}
return(result);
}
public static RequestResult GetDetailViewModel(string equipmentSpecificationId, Account account)
{
RequestResult result = new RequestResult();
try
{
using (CFContext context = new CFContext())
{
var specification = context.ESpecifications.First(x => x.ESpecificationId == new Guid(equipmentSpecificationId));
result.ReturnData(new DetailViewModel()
{
EquipmentSpecificationId = specification.ESpecificationId.ToString(),
Permission = account.OrganizationPermission(specification.OrganizationId),
OrganizationId = specification.OrganizationId.ToString(),
ParentOrganizationFullName = OrganizationDataAccessor.GetOrganizationFullName(specification.OrganizationId),
EquipmentType = specification.EquipmentType,
Name = specification.Name,
EquipmentSpecificationOptonNameList = context.ESOptions.Where(x => x.ESpecificationId == specification.ESpecificationId).OrderBy(x => x.Seq).Select(x => x.Name).ToList()
});
}
}
catch (Exception ex)
{
var err = new Error(MethodBase.GetCurrentMethod(), ex);
Logger.Log(err);
result.ReturnError(err);
}
return(result);
}
public void updateOrganizations(DataSet1 dataSet1)
{
OrganizationDataAccessor DA = new OrganizationDataAccessor();
InvoiceDataAccessor DAinvoice = new InvoiceDataAccessor();
AbstractConnection absConnection = null;
AbstractTransaction absTransaction = null;
try
{
absConnection = DBFactory.createConnection();
absConnection.open();
absTransaction = absConnection.beginTransaction();
DA.Update(absConnection, absTransaction, dataSet1);
DAinvoice.Update(absConnection, absTransaction, dataSet1);
absTransaction.commit();
}
catch (Exception e)
{
absTransaction.rollback();
}
finally
{
absConnection.close();
}
}
public static RequestResult GetEditFormModel(string solutionId)
{
RequestResult result = new RequestResult();
try
{
using (CFContext context = new CFContext())
{
var solution = context.Solutions.First(x => x.SolutionId == new Guid(solutionId));
var model = new EditFormModel()
{
SolutionId = solution.SolutionId.ToString(),
OrganizationId = solution.OrganizationId.ToString(),
ParentOrganizationFullName = OrganizationDataAccessor.GetOrganizationFullName(solution.OrganizationId),
SolutionTypes = new List <SelectListItem>()
{
Define.DefaultSelectListItem(Resources.Resource.Select),
new SelectListItem()
{
Text = Resources.Resource.Create + "...",
Value = Define.New
}
},
FormInput = new FormInput()
{
Type = solution.Type,
SId = solution.SId,
Name = solution.Name
}
};
var upStreamOrganizationIds = OrganizationDataAccessor.GetUpStreamOrganizationIds(new Guid(model.OrganizationId), true);
model.SolutionTypes.AddRange(context.Solutions.Where(x => upStreamOrganizationIds.Contains(x.OrganizationId)).Select(x => x.Type).Distinct().OrderBy(x => x).Select(x => new SelectListItem
{
Value = x,
Text = x
}).ToList());
if (!string.IsNullOrEmpty(model.FormInput.Type) && model.SolutionTypes.Any(x => x.Value == model.FormInput.Type))
{
model.SolutionTypes.First(x => x.Value == model.FormInput.Type).Selected = true;
}
result.ReturnData(model);
}
}
catch (Exception ex)
{
var err = new Error(MethodBase.GetCurrentMethod(), ex);
Logger.Log(err);
result.ReturnError(err);
}
return(result);
}
public static RequestResult GetDetailViewModel(string checkpointId, Account account)
{
RequestResult result = new RequestResult();
try
{
using (CFContext context = new CFContext())
{
var checkpoint = context.Checkpoints.Include("CheckItems").First(x => x.CheckpointId == new Guid(checkpointId));
result.ReturnData(new DetailViewModel()
{
CheckpointId = checkpoint.CheckpointId.ToString(),
Permission = account.OrganizationPermission(checkpoint.OrganizationId),
OrganizationUniqueID = checkpoint.OrganizationId.ToString(),
ParentOrganizationFullName = OrganizationDataAccessor.GetOrganizationFullName(checkpoint.OrganizationId),
CId = checkpoint.CId,
Name = checkpoint.Name,
IsFeelItemDefaultNormal = checkpoint.IsFeelItemDefaultNormal,
TagId = checkpoint.TagId,
Remark = checkpoint.Remark,
CheckItemModels = checkpoint.CheckItems.Select(x=>new CheckItemModel()
{
CheckItemId=x.CheckItemId.ToString(),
CIId=x.CIId,
Name=x.Name,
Type=x.Type,
IsFeelItem=x.IsFeelItem,
IsAccumulation=x.IsAccumulation,
IsInherit=x.IsInherit,
OriLowerLimit=x.LowerLimit,
OriLowerAlertLimit=x.LowerAlertLimit,
OriUpperAlertLimit=x.UpperAlertLimit,
OriUpperLimit=x.UpperLimit,
OriAccumulationBase=x.AccumulationBase,
OriUnit=x.Unit,
OriRemark=x.Remark,
LowerLimit=x.LowerLimit,
LowerAlertLimit=x.LowerAlertLimit,
UpperAlertLimit=x.UpperAlertLimit,
UpperLimit=x.UpperLimit,
AccumulationBase=x.AccumulationBase,
Unit=x.Unit,
Remark=x.Remark
}).OrderBy(x=>x.Type).ThenBy(x=>x.CIId).ToList()
});
}
}
catch (Exception ex)
{
var err = new Error(MethodBase.GetCurrentMethod(), ex);
Logger.Log(err);
result.ReturnError(err);
}
return result;
}
public static RequestResult GetCopyFormModel(string equipmentSpecificationId)
{
RequestResult result = new RequestResult();
try
{
using (CFContext context = new CFContext())
{
var spec = context.ESpecifications.First(x => x.ESpecificationId == new Guid(equipmentSpecificationId));
var model = new CreateFormModel()
{
OrganizationId = spec.OrganizationId.ToString(),
ParentOrganizationFullName = OrganizationDataAccessor.GetOrganizationFullName(spec.OrganizationId),
EquipmentTypeSelectItems = new List <SelectListItem>()
{
Define.DefaultSelectListItem(Resources.Resource.Select),
new SelectListItem()
{
Text = string.Format("{0}...", Resources.Resource.Create),
Value = Define.New
}
},
FormInput = new FormInput()
{
EquipmentType = spec.EquipmentType
},
EquipmentSpecificationOptionModels = context.ESOptions.Where(x => x.ESpecificationId == spec.ESpecificationId).Select(x => new EquipmentSpecificationOptionModel
{
Name = x.Name,
Seq = x.Seq
}).OrderBy(x => x.Seq).ToList()
};
var upStreamOrganizationIds = OrganizationDataAccessor.GetUpStreamOrganizationIds(spec.OrganizationId, true);
model.EquipmentTypeSelectItems.AddRange(context.ESpecifications.Where(x => upStreamOrganizationIds.Contains(x.OrganizationId)).Select(x => x.EquipmentType).Distinct().OrderBy(x => x).Select(x => new SelectListItem
{
Value = x,
Text = x
}).ToList());
model.EquipmentTypeSelectItems.First(x => x.Value == spec.EquipmentType).Selected = true;
result.ReturnData(model);
}
}
catch (Exception ex)
{
var err = new Error(MethodBase.GetCurrentMethod(), ex);
Logger.Log(err);
result.ReturnError(err);
}
return(result);
}
public ActionResult Delete(string organizationId)
{
RequestResult requestResult = OrganizationDataAccessor.Delete(new Guid(organizationId));
if (requestResult.IsSuccess)
{
HttpRuntime.Cache.Remove("Organizations");
}
return(Content(JsonConvert.SerializeObject(requestResult)));
}
public static RequestResult GetCreateFormModel(string organizationId, string materialType)
{
RequestResult requestResult = new RequestResult();
try
{
using (CFContext context = new CFContext())
{
var createFormModel = new CreateFormModel()
{
OrganizationId = organizationId,
ParentOrganizationFullName = OrganizationDataAccessor.GetOrganizationFullName(new Guid(organizationId)),
MaterialTypeSelectItems = new List <SelectListItem>()
{
Define.DefaultSelectListItem(Resources.Resource.Select),
new SelectListItem()
{
Text = string.Format("{0}...", Resources.Resource.Create),
Value = Define.New
}
},
FormInput = new FormInput()
{
MaterialType = materialType
}
};
var upStreamOrganizationIds = OrganizationDataAccessor.GetUpStreamOrganizationIds(new Guid(organizationId), true);
createFormModel.MaterialTypeSelectItems.AddRange(context.MSpecifications.Where(x => upStreamOrganizationIds.Contains(x.OrganizationId)).Select(x => x.MaterialType).Distinct().OrderBy(x => x).Select(x => new SelectListItem
{
Value = x,
Text = x
}).ToList());
if (!string.IsNullOrEmpty(materialType) && createFormModel.MaterialTypeSelectItems.Any(x => x.Value == materialType))
{
createFormModel.MaterialTypeSelectItems.First(x => x.Value == materialType).Selected = true;
}
requestResult.ReturnData(createFormModel);
}
}
catch (Exception ex)
{
var err = new Error(MethodBase.GetCurrentMethod(), ex);
Logger.Log(err);
requestResult.ReturnError(err);
}
return(requestResult);
}
public ActionResult Create(string orgnaizationId)
{
Session["ControlPointFormAction"] = Define.EnumFormAction.Create;
Session["ControlPointCreateFormModel"] = new CreateFormModel()
{
OrganizationId = orgnaizationId,
ParentOrganizationFullName = OrganizationDataAccessor.GetOrganizationFullName(new Guid(orgnaizationId))
};
return(PartialView("_Create", Session["ControlPointCreateFormModel"]));
}
public static RequestResult Query(QueryParameters queryParameters, Account account)
{
RequestResult result = new RequestResult();
try
{
using (CFContext context = new CFContext())
{
var downStreamOrganizationIds = OrganizationDataAccessor.GetDownStreamOrganizationIds(new Guid(queryParameters.OrganizationId), true);
var query = context.Solutions.Where(x => downStreamOrganizationIds.Contains(x.OrganizationId) && account.QueryableOrganizationIds.Contains(x.OrganizationId)).AsQueryable();
if (!string.IsNullOrEmpty(queryParameters.SolutionType))
{
query = query.Where(x => x.OrganizationId == new Guid(queryParameters.OrganizationId) && x.Type == queryParameters.SolutionType);
}
if (!string.IsNullOrEmpty(queryParameters.Keyword))
{
query = query.Where(x => x.SId.Contains(queryParameters.Keyword) || x.Name.Contains(queryParameters.Keyword));
}
var organization = OrganizationDataAccessor.GetOrganization(new Guid(queryParameters.OrganizationId));
result.ReturnData(new GridViewModel()
{
OrganizationId = queryParameters.OrganizationId,
Permission = account.OrganizationPermission(new Guid(queryParameters.OrganizationId)),
SolutionType = queryParameters.SolutionType,
OrganizationName = organization.Name,
FullOrganizationName = organization.FullName,
Items = query.ToList().Select(x => new GridItem()
{
SolutionId = x.SolutionId.ToString(),
Permission = account.OrganizationPermission(x.OrganizationId),
OrganizationName = OrganizationDataAccessor.GetOrganizationName(x.OrganizationId),
SolutionType = x.Type,
SId = x.SId,
Name = x.Name
}).OrderBy(x => x.OrganizationName).ThenBy(x => x.SolutionType).ThenBy(x => x.SId).ToList()
});
}
}
catch (Exception ex)
{
var err = new Error(MethodBase.GetCurrentMethod(), ex);
Logger.Log(err);
result.ReturnError(err);
}
return(result);
}
public static RequestResult GetDetailViewModel(string materialId, Account account)
{
RequestResult requestResult = new RequestResult();
try
{
using (CFContext context = new CFContext())
{
var material = context.Materials.Include("MaterialSpecificationOptions").Where(m => m.MaterialId == new Guid(materialId)).FirstOrDefault();
var materialSpecificationIds = material.MaterialSpecificationOptions.Select(ms => ms.MSpecificationId);
var detailViewModel = new DetailViewModel()
{
Permission = account.OrganizationPermission(material.OrganizationId),
MaterialId = material.MaterialId.ToString(),
OrganizationId = material.OrganizationId.ToString(),
ParentOrganizationName = OrganizationDataAccessor.GetOrganizationFullName(material.OrganizationId),
MaterialType = material.MaterialType,
MId = material.MId,
MaterialName = material.Name,
Quantity = material.Quantity,
MaterialSpecificationModels = context.MSpecifications.Where(ms => materialSpecificationIds.Contains(ms.MSpecificationId)).Select(ms => new MaterialSpecificationModel
{
MaterialSpecificationId = ms.MSpecificationId.ToString(),
Name = ms.Name,
MaterialSpecificationOptionId = context.MaterialSpecificationOptions.Where(x => x.MSpecificationId == ms.MSpecificationId).Select(x => x.MSOptionId).FirstOrDefault().ToString(),
Value = context.MaterialSpecificationOptions.Where(x => x.MSpecificationId == ms.MSpecificationId).Select(x => x.Value).FirstOrDefault().ToString(),
Seq = context.MaterialSpecificationOptions.Where(x => x.MSpecificationId == ms.MSpecificationId).Select(x => x.Seq).FirstOrDefault(),
MaterialSpecificationOptionModels = context.MSOptions.Where(x => x.MSpecificationId == ms.MSpecificationId).Select(mso => new MaterialSpecificationOptionModel
{
MaterialSpecificationOptionId = mso.MSOptionId.ToString(),
MaterialSpecificationId = mso.MSpecificationId.ToString(),
Name = mso.Name,
Seq = mso.Seq
}).OrderBy(mso => mso.Seq).ToList()
}).OrderBy(ms => ms.Seq).ToList()
};
//
requestResult.ReturnData(detailViewModel);
}
}
catch (Exception e)
{
var error = new Error(MethodBase.GetCurrentMethod(), e);
Logger.Log(error);
requestResult.ReturnError(error);
//throw;
}
return(requestResult);
}
public ActionResult AddQueryableOrganization(string Selecteds)
{
RequestResult result = new RequestResult();
try
{
List <Guid> selectedList = JsonConvert.DeserializeObject <List <Guid> >(Selecteds);
if ((Define.EnumFormAction)Session["OrganizationFormAction"] == Define.EnumFormAction.Create)
{
var model = Session["OrganizationCreateFormModel"] as CreateFormModel;
result = OrganizationDataAccessor.AddQueryableOrganization(model.QueryableOrganizations, selectedList, Session["Account"] as Account);
if (result.IsSuccess)
{
model.QueryableOrganizations = result.Data as List <QueryableOrganizationModel>;
Session["OrganizationCreateFormModel"] = model;
}
}
else if ((Define.EnumFormAction)Session["OrganizationFormAction"] == Define.EnumFormAction.Edit)
{
var model = Session["OrganizationEditFormModel"] as EditFormModel;
result = OrganizationDataAccessor.AddQueryableOrganization(model.QueryableOrganizations, selectedList, Session["Account"] as Account);
if (result.IsSuccess)
{
model.QueryableOrganizations = result.Data as List <QueryableOrganizationModel>;
Session["OrganizationEditFormModel"] = model;
}
}
else
{
result.ReturnFailedMessage(Resources.Resource.UnKnownOperation);
}
}
catch (Exception ex)
{
Error err = new Error(MethodBase.GetCurrentMethod(), ex);
Logger.Log(err);
result.ReturnError(err);
}
return(Content(JsonConvert.SerializeObject(result)));
}
public ActionResult InitTree()
{
try
{
var account = Session["Account"] as Account;
account.OrganizationPermissions = OrganizationDataAccessor.GetOrganizationPermissions(account.OrganizationId);
Session["Account"] = account;
var organizations = HttpRuntime.Cache.GetOrInsert("Organizations", () => OrganizationDataAccessor.GetAllOrganizations());
RequestResult requestResult = new RequestResult();
if (account.RootOrganizationId == new Guid())
{
requestResult = OrganizationDataAccessor.GetTreeItem(organizations, account.RootOrganizationId, account);
}
else
{
requestResult = OrganizationDataAccessor.GetRootTreeItem(organizations, account.RootOrganizationId, account);
}
if (requestResult.IsSuccess)
{
return(PartialView("_Tree", JsonConvert.SerializeObject((List <TreeItem>)requestResult.Data)));
}
else
{
return(PartialView("_Error", requestResult.Error));
}
}
catch (Exception e)
{
var error = new Error(MethodBase.GetCurrentMethod(), e);
Logger.Log(error);
return(PartialView("_Error", error));
throw;
}
}
public ActionResult Create(string parentOrganizationId)
{
try
{
if (parentOrganizationId == "00000000-0000-0000-0000-000000000000")
{
Session["OrganizationCreateFormModel"] = new CreateFormModel()
{
AncestorOrganizationId = "00000000-0000-0000-0000-000000000000",
ParentId = "00000000-0000-0000-0000-000000000000",
ParentOrganizationFullName = "*"
};
}
else
{
var parentOrganization = OrganizationDataAccessor.GetOrganization(new Guid(parentOrganizationId));
Session["OrganizationCreateFormModel"] = new CreateFormModel()
{
AncestorOrganizationId = parentOrganization.AncestorOrganizationId.ToString(),
ParentId = parentOrganization.OrganizationId.ToString(),
ParentOrganizationFullName = parentOrganization.FullName
};
}
Session["OrganizationFormAction"] = Define.EnumFormAction.Create;
return(PartialView("_Create", Session["OrganizationCreateFormModel"]));
}
catch (Exception ex)
{
var err = new Error(MethodBase.GetCurrentMethod(), ex);
Logger.Log(err);
return(PartialView("_Error", err));
}
}
public ActionResult Detail(string organizationId)
{
try
{
RequestResult requestResult = OrganizationDataAccessor.GetDetailViewModel(new Guid(organizationId), Session["Account"] as Account);
if (requestResult.IsSuccess)
{
return(PartialView("_Detail", requestResult.Data));
}
else
{
return(PartialView("_Error", requestResult.Error));
}
}
catch (Exception e)
{
var error = new Error(MethodBase.GetCurrentMethod(), e);
Logger.Log(error);
return(PartialView("_Error", error));
}
}
public ActionResult GetTreeItem(string organizationId, string solutionType)
{
string jsonTree = string.Empty;
try
{
var organizationList = HttpRuntime.Cache.GetOrInsert <List <Models.Shared.Organization> >("Organizations", () => OrganizationDataAccessor.GetAllOrganizations());
RequestResult result = SolutionDataAccessor.GetTreeItems(organizationList, new Guid(organizationId), solutionType, Session["Account"] as Account);
if (result.IsSuccess)
{
jsonTree = JsonConvert.SerializeObject((List <TreeItem>)result.Data);
}
else
{
jsonTree = string.Empty;
}
}
catch (Exception ex)
{
Logger.Log(MethodBase.GetCurrentMethod(), ex);
jsonTree = string.Empty;
}
return(Content(jsonTree));
}
public ActionResult InitTree()
{
try
{
var organizationList = HttpRuntime.Cache.GetOrInsert <List <Models.Shared.Organization> >("Organizations", () => OrganizationDataAccessor.GetAllOrganizations());
var account = Session["Account"] as Account;
RequestResult result = new RequestResult();
if (account.RootOrganizationId == new Guid())
{
result = SolutionDataAccessor.GetTreeItems(organizationList, account.RootOrganizationId, "", Session["Account"] as Account);
}
else
{
result = SolutionDataAccessor.GetRootTreeItems(organizationList, account.RootOrganizationId, Session["Account"] as Account);
}
if (result.IsSuccess)
{
return(PartialView("_Tree", JsonConvert.SerializeObject((List <TreeItem>)result.Data)));
}
else
{
return(PartialView("_Error", result.Error));
}
}
catch (Exception ex)
{
var err = new Error(MethodBase.GetCurrentMethod(), ex);
Logger.Log(err);
return(PartialView("_Error", err));
}
}
public static RequestResult AddMaterialSpecification(List <MaterialSpecificationModel> materialSpecificationModels, List <string> selectedList, string refOrganizationId)
{
RequestResult result = new RequestResult();
try
{
using (CFContext context = new CFContext())
{
foreach (string selected in selectedList)
{
string[] temp = selected.Split(Define.Seperators, StringSplitOptions.None);
var organizationId = temp[0];
var materialType = temp[1];
var specUniqueID = temp[2];
if (!string.IsNullOrEmpty(specUniqueID))
{
if (!materialSpecificationModels.Any(x => x.MaterialSpecificationId == specUniqueID))
{
var spec = context.MSpecifications.First(x => x.MSpecificationId == new Guid(specUniqueID));
materialSpecificationModels.Add(new MaterialSpecificationModel()
{
MaterialSpecificationId = spec.MSpecificationId.ToString(),
Name = spec.Name,
Seq = materialSpecificationModels.Count + 1,
MaterialSpecificationOptionModels = context.MSOptions.Where(x => x.MSpecificationId == spec.MSpecificationId).Select(x => new MaterialSpecificationOptionModel
{
MaterialSpecificationOptionId = x.MSOptionId.ToString(),
Name = x.Name,
Seq = x.Seq,
MaterialSpecificationId = x.MSpecificationId.ToString()
}).OrderBy(x => x.Name).ToList()
});
}
}
else
{
if (!string.IsNullOrEmpty(materialType))
{
var specList = context.MSpecifications.Where(x => x.OrganizationId == new Guid(organizationId) && x.MaterialType == materialType).ToList();
foreach (var spec in specList)
{
if (!materialSpecificationModels.Any(x => x.MaterialSpecificationId == spec.MSpecificationId.ToString()))
{
materialSpecificationModels.Add(new MaterialSpecificationModel()
{
MaterialSpecificationId = spec.MSpecificationId.ToString(),
Name = spec.Name,
Seq = materialSpecificationModels.Count + 1,
MaterialSpecificationOptionModels = context.MSOptions.Where(x => x.MSpecificationId == spec.MSpecificationId).Select(x => new MaterialSpecificationOptionModel
{
MaterialSpecificationOptionId = x.MSpecificationId.ToString(),
Name = x.Name,
Seq = x.Seq,
MaterialSpecificationId = x.MSpecificationId.ToString()
}).OrderBy(x => x.Name).ToList()
});
}
}
}
else
{
var availableOrganizationIds = OrganizationDataAccessor.GetUpStreamOrganizationIds(new Guid(refOrganizationId), true);
var downStreamOrganizationIds = OrganizationDataAccessor.GetDownStreamOrganizationIds(new Guid(organizationId), true);
foreach (var downStreamOrganization in downStreamOrganizationIds)
{
if (availableOrganizationIds.Any(x => x == downStreamOrganization))
{
var specList = context.MSpecifications.Where(x => x.OrganizationId == downStreamOrganization).ToList();
foreach (var spec in specList)
{
if (!materialSpecificationModels.Any(x => x.MaterialSpecificationId == spec.MSpecificationId.ToString()))
{
materialSpecificationModels.Add(new MaterialSpecificationModel()
{
MaterialSpecificationId = spec.MSpecificationId.ToString(),
Name = spec.Name,
Seq = materialSpecificationModels.Count + 1,
MaterialSpecificationOptionModels = context.MSOptions.Where(x => x.MSpecificationId == spec.MSpecificationId).Select(x => new MaterialSpecificationOptionModel
{
MaterialSpecificationOptionId = x.MSOptionId.ToString(),
Name = x.Name,
Seq = x.Seq,
MaterialSpecificationId = x.MSpecificationId.ToString()
}).OrderBy(x => x.Name).ToList()
});
}
}
}
}
}
}
}
}
materialSpecificationModels = materialSpecificationModels.OrderBy(x => x.Name).ToList();
result.ReturnData(materialSpecificationModels);
}
catch (Exception ex)
{
var err = new Error(MethodBase.GetCurrentMethod(), ex);
Logger.Log(err);
result.ReturnError(err);
}
return(result);
}
public static RequestResult GetCopyFormModel(Guid materialId)
{
RequestResult requestResult = new RequestResult();
try
{
using (CFContext context = new CFContext())
{
var material = context.Materials.First(x => x.MaterialId == materialId);
var createFormModel = new CreateFormModel()
{
OrganizationId = material.OrganizationId.ToString(),
ParentOrganizationFullName = OrganizationDataAccessor.GetOrganizationFullName(material.OrganizationId),
MaterialTypeSelectItems = new List <SelectListItem>()
{
Define.DefaultSelectListItem(Resources.Resource.Select),
new SelectListItem()
{
Text = Resources.Resource.Create + "...",
Value = Define.New
}
},
FormInput = new FormInput()
{
MaterialType = material.MaterialType
},
MaterialSpecificationModels = (from x in context.MaterialSpecificationOptions
join s in context.MSpecifications
on x.MSpecificationId equals s.MSpecificationId
where x.MaterialId == material.MaterialId
select new MaterialSpecificationModel
{
MaterialSpecificationId = s.MSpecificationId.ToString(),
Name = s.Name,
MaterialSpecificationOptionId = x.MSOptionId.ToString(),
Value = x.Value,
Seq = x.Seq,
MaterialSpecificationOptionModels = context.MSOptions.Where(o => o.MSpecificationId == s.MSpecificationId).Select(o => new MaterialSpecificationOptionModel
{
MaterialSpecificationId = o.MSpecificationId.ToString(),
Seq = o.Seq,
Name = o.Name,
MaterialSpecificationOptionId = o.MSOptionId.ToString()
}).OrderBy(o => o.Seq).ToList()
}).OrderBy(x => x.Seq).ToList()
};
var upStreamOrganizationIds = OrganizationDataAccessor.GetUpStreamOrganizationIds(material.OrganizationId, true);
createFormModel.MaterialTypeSelectItems.AddRange(context.Materials.Where(x => upStreamOrganizationIds.Contains(x.OrganizationId)).Select(x => x.MaterialType).Distinct().OrderBy(x => x).Select(x => new SelectListItem
{
Value = x,
Text = x
}).ToList());
createFormModel.MaterialTypeSelectItems.First(x => x.Value == material.MaterialType).Selected = true;
requestResult.ReturnData(createFormModel);
}
}
catch (Exception e)
{
var error = new Error(MethodBase.GetCurrentMethod(), e);
Logger.Log(error);
requestResult.ReturnError(error);
}
return(requestResult);
}
public static RequestResult GetTreeItems(List <Models.Shared.Organization> organizationList, Guid refOrganizationId, Guid organizationId, string materialType)
{
RequestResult result = new RequestResult();
try
{
var treeItemList = new List <TreeItem>();
var attributes = new Dictionary <Define.EnumTreeAttribute, string>()
{
{ Define.EnumTreeAttribute.NodeType, string.Empty },
{ Define.EnumTreeAttribute.ToolTip, string.Empty },
{ Define.EnumTreeAttribute.OrganizationId, string.Empty },
{ Define.EnumTreeAttribute.EquipmentType, string.Empty },
{ Define.EnumTreeAttribute.MaterialId, string.Empty }
};
using (CFContext context = new CFContext())
{
if (string.IsNullOrEmpty(materialType))
{
var materialTypes = context.Materials.Where(x => x.OrganizationId == organizationId).Select(x => x.MaterialType).Distinct().OrderBy(x => x).ToList();
foreach (var type in materialTypes)
{
var treeItem = new TreeItem()
{
Title = type
};
attributes[Define.EnumTreeAttribute.NodeType] = Define.EnumTreeNodeType.EquipmentType.ToString();
attributes[Define.EnumTreeAttribute.ToolTip] = type;
attributes[Define.EnumTreeAttribute.OrganizationId] = organizationId.ToString();
attributes[Define.EnumTreeAttribute.EquipmentType] = type;
attributes[Define.EnumTreeAttribute.MaterialId] = string.Empty;
foreach (var attribute in attributes)
{
treeItem.Attributes[attribute.Key.ToString()] = attribute.Value;
}
treeItem.State = "closed";
treeItemList.Add(treeItem);
}
var availableOrganizationIds = OrganizationDataAccessor.GetUpStreamOrganizationIds(refOrganizationId, true);
var organizations = organizationList.Where(x => x.ParentId == organizationId && availableOrganizationIds.Contains(x.OrganizationId)).OrderBy(x => x.OId).ToList();
foreach (var organization in organizations)
{
var downStreamOrganizationIds = OrganizationDataAccessor.GetDownStreamOrganizationIds(organization.OrganizationId, true);
if (context.Materials.Any(x => downStreamOrganizationIds.Contains(x.OrganizationId) && availableOrganizationIds.Contains(x.OrganizationId)))
{
var treeItem = new TreeItem()
{
Title = organization.Name
};
attributes[Define.EnumTreeAttribute.NodeType] = Define.EnumTreeNodeType.Organization.ToString();
attributes[Define.EnumTreeAttribute.ToolTip] = string.Format("{0}/{1}", organization.OId, organization.Name);
attributes[Define.EnumTreeAttribute.OrganizationId] = organization.OrganizationId.ToString();
attributes[Define.EnumTreeAttribute.EquipmentType] = string.Empty;
attributes[Define.EnumTreeAttribute.MaterialId] = string.Empty;
foreach (var attribute in attributes)
{
treeItem.Attributes[attribute.Key.ToString()] = attribute.Value;
}
treeItem.State = "closed";
treeItemList.Add(treeItem);
}
}
}
else
{
var materialList = context.Materials.Where(x => x.OrganizationId == organizationId && x.MaterialType == materialType).OrderBy(x => x.MId).ToList();
foreach (var material in materialList)
{
var treeItem = new TreeItem()
{
Title = material.Name
};
attributes[Define.EnumTreeAttribute.NodeType] = Define.EnumTreeNodeType.Material.ToString();
attributes[Define.EnumTreeAttribute.ToolTip] = string.Format("{0}/{1}", material.MId, material.Name);
attributes[Define.EnumTreeAttribute.OrganizationId] = material.OrganizationId.ToString();
attributes[Define.EnumTreeAttribute.MaterialType] = material.MaterialType;
attributes[Define.EnumTreeAttribute.MaterialId] = material.MaterialId.ToString();
foreach (var attribute in attributes)
{
treeItem.Attributes[attribute.Key.ToString()] = attribute.Value;
}
treeItemList.Add(treeItem);
}
}
}
result.ReturnData(treeItemList);
}
catch (Exception ex)
{
var err = new Error(MethodBase.GetCurrentMethod(), ex);
Logger.Log(err);
result.ReturnError(err);
}
return(result);
}
public ActionResult Login(LoginFormModel loginFormModel)
{
RequestResult requestResult = AccountDataAccessor.GetAccount(loginFormModel);
if (requestResult.IsSuccess)
{
var person = requestResult.Data as Person;
if (Config.HaveLDAPSettings)
{
return(View());
}
else
{
if (string.Compare(person.Password, loginFormModel.Password) == 0)
{
var organizations = HttpRuntime.Cache.GetOrInsert("organizations", () => OrganizationDataAccessor.GetAllOrganizations());
requestResult = AccountDataAccessor.GetAccount(organizations, person);
if (requestResult.IsSuccess)
{
var account = requestResult.Data as Account;
var ticket = new FormsAuthenticationTicket(1, account.Id, DateTime.Now, DateTime.Now.AddHours(24), true, account.Id, FormsAuthentication.FormsCookiePath);
string encTicket = FormsAuthentication.Encrypt(ticket);
Response.Cookies.Add(new HttpCookie(FormsAuthentication.FormsCookieName, encTicket));
Session["Account"] = account;
return(RedirectToAction("Index"));
}
else
{
ModelState.AddModelError("LoginId", requestResult.Message);
return(View());
}
}
else
{
ModelState.AddModelError("Password", Resources.Resource.WrongPassword);
return(View());
}
}
}
else
{
ModelState.AddModelError("LoginId", requestResult.Message);
return(View());
}
}
public ActionResult InitSelectTree(string refOrganizationId)
{
try
{
var organizations = HttpRuntime.Cache.GetOrInsert <List <Models.Shared.Organization> >("Organizations", () => OrganizationDataAccessor.GetAllOrganizations());
RequestResult result = CheckItemDataAccessor.GetTreeItems(organizations, new Guid(refOrganizationId), new Guid(), "");
if (result.IsSuccess)
{
return(PartialView("_SelectTree", JsonConvert.SerializeObject((List <TreeItem>)result.Data)));
}
else
{
return(PartialView("_Error", result.Error));
}
}
catch (Exception ex)
{
var err = new Error(MethodBase.GetCurrentMethod(), ex);
Logger.Log(err);
return(PartialView("_Error", err));
}
}
public void organizationDelete()
{
DataSet1 dataSetRead = new DataSet1();
OrganizationDataAccessor dalOrganization = new OrganizationDataAccessor();
AbstractConnection absCon_Read = null;
AbstractTransaction absTran_Read = null;
int countRowBefore = 0;
try
{
absCon_Read = DBFactory.createConnection();
absCon_Read.open();
absTran_Read = absCon_Read.beginTransaction();
dalOrganization.Read(absCon_Read, absTran_Read, dataSetRead);
List <DataRow> rows_list = dataSetRead.organization.Select("organization_name = 'ОАО \"КРАСНОЯРСКЛЕСОМАТЕРИАЛЫ\"'").OfType <DataRow>().ToList();
// Сортируем строки по id в порядке возрастания
rows_list.Sort((x, y) => ((int)x["id"]).CompareTo((int)y["id"]));
// Количество записей до удаления
countRowBefore = rows_list.Count();
absTran_Read.commit();
}
catch (Exception e)
{
absTran_Read.rollback();
}
finally
{
absCon_Read.close();
}
Assert.That(countRowBefore, Is.EqualTo(1));
// НОВОЕ СОЕДИНЕНИЕ, удаляем
AbstractConnection absCon_Update = null;
AbstractTransaction absTran_Update = null;
List <DataRow> list_1 = dataSetRead.organization.Select("organization_name = 'ОАО \"КРАСНОЯРСКЛЕСОМАТЕРИАЛЫ\"'").OfType <DataRow>().ToList();
foreach (DataRow rowForDel in list_1)
{
dataSetRead.organization.Rows.Remove(rowForDel);
}
try
{
absCon_Update = DBFactory.createConnection();
absCon_Update.open();
absTran_Update = absCon_Update.beginTransaction();
dalOrganization.Update(absCon_Update, absTran_Update, dataSetRead);
absTran_Update.commit();
}
catch (Exception e)
{
absTran_Update.rollback();
}
finally
{
absCon_Update.close();
}
// Новый коннекшн, проверяем что теперь записей стало на одну больше
AbstractConnection absCon_AfterInsert = null;
AbstractTransaction absTran_AfterInsert = null;
DataSet1 dataSet_AfterInsert = new DataSet1();
OrganizationDataAccessor organizationDA_AfterInsert = new OrganizationDataAccessor();
try
{
absCon_AfterInsert = DBFactory.createConnection();
absCon_AfterInsert.open();
absTran_AfterInsert = absCon_AfterInsert.beginTransaction();
organizationDA_AfterInsert.Read(absCon_AfterInsert, absTran_AfterInsert, dataSet_AfterInsert);
absTran_AfterInsert.commit();
}
catch (Exception e)
{
absTran_AfterInsert.commit();
}
finally
{
absCon_AfterInsert.close();
}
List <DataRow> rows_list_AfterInsert = dataSetRead.organization.Select("organization_name = 'ОАО \"КРАСНОЯРСКЛЕСОМАТЕРИАЛЫ\"'").OfType <DataRow>().ToList();
Assert.That(rows_list_AfterInsert.Count, Is.EqualTo(0));
}
