public async Task <IActionResult> Post([FromBody] InventoryDocumentViewModel viewModel)
{
try
{
VerifyUser();
ValidateService.Validate(viewModel);
InventoryDocument model = Service.MapToModel(viewModel);
await Service.Create(model);
Dictionary <string, object> Result =
new ResultFormatter(ApiVersion, General.CREATED_STATUS_CODE, General.OK_MESSAGE)
.Ok();
return(Created(String.Concat(Request.Path, "/", 0), Result));
}
catch (ServiceValidationExeption e)
{
Dictionary <string, object> Result =
new ResultFormatter(ApiVersion, General.BAD_REQUEST_STATUS_CODE, General.BAD_REQUEST_MESSAGE)
.Fail(e);
return(BadRequest(Result));
}
catch (Exception e)
{
Dictionary <string, object> Result =
new ResultFormatter(ApiVersion, General.INTERNAL_ERROR_STATUS_CODE, e.Message)
.Fail();
return(StatusCode(General.INTERNAL_ERROR_STATUS_CODE, Result));
}
}
public IActionResult GetById(int id)
{
try
{
var indexAcceptPdf = Request.Headers["Accept"].ToList().IndexOf("application/pdf");
InventoryDocument model = Service.ReadModelById(id);
if (model == null)
{
Dictionary <string, object> Result =
new ResultFormatter(ApiVersion, General.NOT_FOUND_STATUS_CODE, General.NOT_FOUND_MESSAGE)
.Fail();
return(NotFound(Result));
}
else
{
Dictionary <string, object> Result =
new ResultFormatter(ApiVersion, General.OK_STATUS_CODE, General.OK_MESSAGE)
.Ok <InventoryDocument, InventoryDocumentViewModel>(model, Service.MapToViewModel);
return(Ok(Result));
}
}
catch (Exception e)
{
Dictionary <string, object> Result =
new ResultFormatter(ApiVersion, General.INTERNAL_ERROR_STATUS_CODE, e.Message)
.Fail();
return(StatusCode(General.INTERNAL_ERROR_STATUS_CODE, Result));
}
}
public async void Should_Success_Create_Data()
{
InventoryDocument model = DataUtil.GetNewData();
var Response = await Facade.Create(model, "Unit Test");
Assert.NotEqual(Response, 0);
}
string GenerateNo(InventoryDocument model)
{
do
{
model.No = CodeGenerator.GenerateCode();
}while (this.dbSet.Any(d => d.No.Equals(model.No)));
return(model.No);
//string Year = model.Date.ToString("yy");
//string Month = model.Date.ToString("MM");
//string no = $"DOC-{Year}-{Month}-{model.StorageCode}-";
//int Padding = 7;
//var lastNo = await this.dbSet.Where(w => w.No.StartsWith(no) && !w._IsDeleted).OrderByDescending(o => o.No).FirstOrDefaultAsync();
//if (lastNo == null)
//{
// return no + "1".PadLeft(Padding, '0');
//}
//else
//{
// int lastNoNumber = Int32.Parse(lastNo.No.Replace(no, "")) + 1;
// return no + lastNoNumber.ToString().PadLeft(Padding, '0');
//}
}
public async Task <int> CreateInventoryDocumentAsync(Models.FpRegradingResultDocs Model, string Type)
{
string storageURI = "master/storages";
string uomURI = "master/uoms";
IHttpService httpClient = (IHttpService)this.ServiceProvider.GetService(typeof(IHttpService));
/* Get UOM */
Dictionary <string, object> filterUOM = new Dictionary <string, object> {
{ "unit", "MTR" }
};
var responseUOM = httpClient.GetAsync($@"{APIEndpoint.Core}{uomURI}?filter=" + JsonConvert.SerializeObject(filterUOM)).Result.Content.ReadAsStringAsync();
Dictionary <string, object> resultUOM = JsonConvert.DeserializeObject <Dictionary <string, object> >(responseUOM.Result);
var jsonUOM = resultUOM.Single(p => p.Key.Equals("data")).Value;
Dictionary <string, object> uom = JsonConvert.DeserializeObject <List <Dictionary <string, object> > >(jsonUOM.ToString())[0];
/* Get Storage */
var storageName = Model.UnitName.Equals("PRINTING") ? "Gudang Greige Printing" : "Gudang Greige Finishing";
Dictionary <string, object> filterStorage = new Dictionary <string, object> {
{ "name", storageName }
};
var responseStorage = httpClient.GetAsync($@"{APIEndpoint.Core}{storageURI}?filter=" + JsonConvert.SerializeObject(filterStorage)).Result.Content.ReadAsStringAsync();
Dictionary <string, object> resultStorage = JsonConvert.DeserializeObject <Dictionary <string, object> >(responseStorage.Result);
var jsonStorage = resultStorage.Single(p => p.Key.Equals("data")).Value;
Dictionary <string, object> storage = JsonConvert.DeserializeObject <List <Dictionary <string, object> > >(jsonStorage.ToString())[0];
/* Create Inventory Document */
List <InventoryDocumentItem> inventoryDocumentItems = new List <InventoryDocumentItem>();
InventoryDocumentItem inventoryDocumentItem = new InventoryDocumentItem();
double TotalLength = 0;
foreach (FpRegradingResultDocsDetails o in Model.Details)
{
TotalLength += o.Length;
}
inventoryDocumentItem.ProductId = int.Parse(Model.ProductId);
inventoryDocumentItem.ProductCode = Model.ProductCode;
inventoryDocumentItem.ProductName = Model.ProductName;
inventoryDocumentItem.Quantity = TotalLength;
inventoryDocumentItem.UomId = int.Parse(uom["Id"].ToString());
inventoryDocumentItem.UomUnit = uom["Unit"].ToString();
inventoryDocumentItems.Add(inventoryDocumentItem);
InventoryDocument inventoryDocument = new InventoryDocument
{
Date = DateTimeOffset.UtcNow,
ReferenceNo = Model.Code,
ReferenceType = "Bon Hasil Re-grading",
Type = Type,
StorageId = int.Parse(storage["_id"].ToString()),
StorageCode = storage["code"].ToString(),
StorageName = storage["name"].ToString(),
Items = inventoryDocumentItems
};
var inventoryDocumentFacade = ServiceProvider.GetService <IInventoryDocumentService>();
return(await inventoryDocumentFacade.Create(inventoryDocument));
}
public async Task <InventoryDocument> GetTestData()
{
InventoryDocument invDoc = GetNewData();
await _inventoryDocumentRepository.Create(invDoc);
return(invDoc);
}
public async Task <InventoryDocument> GetTestData()
{
InventoryDocument invDoc = GetNewData();
await Service.Create(invDoc);
return(invDoc);
}
public async void Should_Success_Get_Data_By_Id()
{
InventoryDocument model = await DataUtil.GetTestData("Unit test");
var Response = Facade.ReadModelById((int)model.Id);
Assert.NotNull(Response);
}
public async Task <InventoryDocument> GetTestData(string user)
{
InventoryDocument invDoc = GetNewData();
await facade.Create(invDoc, user);
return(invDoc);
}
private string GenerateNo(InventoryDocument model)
{
do
{
model.No = CodeGenerator.GenerateCode();
}while (this._dbSet.Any(d => d.No.Equals(model.No)));
return(model.No);
}
public IActionResult Get(int id)
{
try
{
var indexAcceptPdf = Request.Headers["Accept"].ToList().IndexOf("application/pdf");
InventoryDocument model = _facade.ReadModelById(id);
//InventoryDocumentViewModel viewModel = _mapper.Map<InventoryDocumentViewModel>(model);
List <InventoryDocumentItemViewModel> items = new List <InventoryDocumentItemViewModel>();
foreach (var item in model.Items)
{
items.Add(new InventoryDocumentItemViewModel
{
productCode = item.ProductCode,
productId = item.ProductId,
productName = item.ProductName,
remark = item.ProductRemark,
quantity = item.Quantity,
stockPlanning = item.StockPlanning,
uomId = item.UomId,
uom = item.UomUnit,
});
}
InventoryDocumentViewModel viewModel = new InventoryDocumentViewModel
{
referenceNo = model.ReferenceNo,
referenceType = model.ReferenceType,
remark = model.Remark,
storageCode = model.StorageCode,
storageId = model.StorageId.ToString(),
storageName = model.StorageName,
date = model.Date,
type = model.Type,
items = items
};
if (viewModel == null)
{
throw new Exception("Invalid Id");
}
return(Ok(new
{
apiVersion = ApiVersion,
statusCode = General.OK_STATUS_CODE,
message = General.OK_MESSAGE,
data = viewModel,
}));
}
catch (Exception e)
{
Dictionary <string, object> Result =
new ResultFormatter(ApiVersion, General.INTERNAL_ERROR_STATUS_CODE, e.Message)
.Fail();
return(StatusCode(General.INTERNAL_ERROR_STATUS_CODE, Result));
}
}
// Generate SignalR Message
private static string GenerateInventoryMessage(InventoryDocument document)
{
var message = new JObject();
message["Product"] = document.id;
foreach (var location in document.stock)
{
message[location.Key] = location.Value;
}
return(message.ToString());
}
public override InventorySheet CreateNew()
{
InventoryDocument parent = (InventoryDocument)this.Parent;
//create new object and attach it to the element
InventorySheet line = new InventorySheet(parent);
line.Order = this.Children.Count + 1;
//add object to the collection
this.Children.Add(line);
return(line);
}
public static void CreateInventorySheetToInventoryDocument(InventorySheet destination, XElement source)
{
Guid inventoryDocumentId = new Guid(source.Element("inventoryDocumentId").Value);
destination.InventoryDocumentHeaderId = inventoryDocumentId;
using (DocumentCoordinator c = new DocumentCoordinator(false, false))
{
InventoryDocument inventoryDocument = (InventoryDocument)c.LoadBusinessObject(BusinessObjectType.InventoryDocument, inventoryDocumentId);
destination.Tag = inventoryDocument.Version.ToUpperString();
destination.OrdinalNumber = inventoryDocument.Sheets.Children.Count + 1;
destination.InventoryDocumentFullNumber = inventoryDocument.Number.FullNumber;
destination.WarehouseId = inventoryDocument.WarehouseId;
}
}
public void SaveInventory(string characterID, ServerInventory serverInventory)
{
lock (sync) {
log.InfoFormat("SAVE INVENTORY FOR CHAR = {0} INV COUNT = {1} [red]", characterID, serverInventory.SlotsUsed);
var document = InventoryDocuments.FindOne(Query <InventoryDocument> .EQ(d => d.CharacterId, characterID));
if (document == null)
{
document = new InventoryDocument {
CharacterId = characterID
};
}
document.Set(serverInventory);
InventoryDocuments.Save(document);
}
}
private async Task CreateInventory(FpReturnFromBuyerModel model, string type)
{
var inventoryDocument = new InventoryDocument()
{
Date = model.Date,
Items = GetInventoryItems(model.Details),
ReferenceNo = model.Code,
ReferenceType = "Return From Buyer",
StorageCode = model.StorageCode,
StorageId = model.StorageId,
StorageName = model.StorageName,
Type = type
};
await _inventoryDocumentService.Create(inventoryDocument);
}
public ServerInventory LoadInventory(string characterID, Res resource)
{
lock (sync) {
log.InfoFormat("LOAD INVENTORY FOR CHAR = {0} [red]", characterID);
var document = InventoryDocuments.FindOne(Query <InventoryDocument> .EQ(d => d.CharacterId, characterID));
if (document != null)
{
return(document.SourceObject(resource));
}
else
{
document = new InventoryDocument {
CharacterId = characterID, Items = new List <InventoryItemDocumentElement>(), MaxSlots = 0
};
InventoryDocuments.Save(document);
return(document.SourceObject(resource));
}
}
}
async Task <string> GenerateNo(InventoryDocument model)
{
string Year = model.Date.ToString("yy");
string Month = model.Date.ToString("MM");
string no = $"DOC-{Year}-{Month}-{model.StorageCode}-{model.ReferenceType}-";
int Padding = 7;
var lastNo = await this.dbSet.Where(w => w.No.StartsWith(no) && !w._IsDeleted).OrderByDescending(o => o.No).FirstOrDefaultAsync();
if (lastNo == null)
{
return(no + "1".PadLeft(Padding, '0'));
}
else
{
int lastNoNumber = Int32.Parse(lastNo.No.Replace(no, "")) + 1;
return(no + lastNoNumber.ToString().PadLeft(Padding, '0'));
}
}
public async Task <int> CreateInventoryDocument(StockTransferNote Model, string Type, string Context)
{
StockTransferNoteViewModel ViewModel = MapToViewModel(Model);
IHttpServiceRepository httpClient = (IHttpServiceRepository)this.ServiceProvider.GetService(typeof(IHttpServiceRepository));
/* Create Inventory Document */
List <InventoryDocumentItem> inventoryDocumentItems = new List <InventoryDocumentItem>();
foreach (StockTransferNoteItemViewModel stni in ViewModel.StockTransferNoteItems)
{
InventoryDocumentItem inventoryDocumentItem = new InventoryDocumentItem
{
ProductId = stni.Summary.ProductId,
ProductCode = stni.Summary.ProductCode,
ProductName = stni.Summary.ProductName,
Quantity = stni.TransferedQuantity != null ? (double)stni.TransferedQuantity : 0,
UomId = stni.Summary.UomId,
UomUnit = stni.Summary.Uom
};
inventoryDocumentItems.Add(inventoryDocumentItem);
}
InventoryDocument inventoryDocument = new InventoryDocument
{
Date = DateTimeOffset.UtcNow,
ReferenceNo = Model.ReferenceNo,
ReferenceType = Model.ReferenceType,
Type = Type,
StorageId = string.Equals(Context.ToUpper(), "CREATE") || string.Equals(Context.ToUpper(), "DELETE-SOURCE") ? int.Parse(Model.SourceStorageId) : int.Parse(Model.TargetStorageId),
StorageCode = string.Equals(Context.ToUpper(), "CREATE") || string.Equals(Context.ToUpper(), "DELETE-SOURCE") ? Model.SourceStorageCode : Model.TargetStorageCode,
StorageName = string.Equals(Context.ToUpper(), "CREATE") || string.Equals(Context.ToUpper(), "DELETE-SOURCE") ? Model.SourceStorageName : Model.TargetStorageName,
Items = inventoryDocumentItems
};
var inventoryDocumentFacade = ServiceProvider.GetService <IInventoryDocumentRepository>();
return(await inventoryDocumentFacade.Create(inventoryDocument));
}
public InventoryDocumentViewModel MapToViewModel(InventoryDocument model)
{
InventoryDocumentViewModel viewModel = new InventoryDocumentViewModel
{
No = model.No,
ReferenceNo = model.ReferenceNo,
ReferenceType = model.ReferenceType,
Remark = model.Remark,
StorageCode = model.StorageCode,
StorageId = model.StorageId,
StorageName = model.StorageName,
Date = model.Date,
Type = model.Type,
Items = model.Items.Select(item => new InventoryDocumentItemViewModel()
{
Id = item.Id,
Active = item.Active,
CreatedAgent = item.CreatedAgent,
CreatedBy = item.CreatedBy,
CreatedUtc = item.CreatedUtc,
IsDeleted = item.IsDeleted,
LastModifiedAgent = item.LastModifiedAgent,
LastModifiedBy = item.LastModifiedBy,
LastModifiedUtc = item.LastModifiedUtc,
ProductCode = item.ProductCode,
ProductId = item.ProductId,
ProductName = item.ProductName,
Remark = item.ProductRemark,
Quantity = item.Quantity,
StockPlanning = item.StockPlanning,
UomId = item.UomId,
Uom = item.UomUnit,
}).ToList()
};
PropertyCopier <InventoryDocument, InventoryDocumentViewModel> .Copy(model, viewModel);
return(viewModel);
}
public InventoryDocumentViewModel MapToViewModel(InventoryDocument model)
{
InventoryDocumentViewModel viewModel = new InventoryDocumentViewModel
{
no = model.No,
referenceNo = model.ReferenceNo,
referenceType = model.ReferenceType,
remark = model.Remark,
storageCode = model.StorageCode,
storageId = model.StorageId,
storageName = model.StorageName,
date = model.Date,
type = model.Type,
items = model.Items.Select(item => new InventoryDocumentItemViewModel()
{
Id = item.Id,
Active = item.Active,
_CreatedAgent = item._CreatedAgent,
_CreatedBy = item._CreatedBy,
_CreatedUtc = item._CreatedUtc,
_IsDeleted = item._IsDeleted,
_LastModifiedAgent = item._LastModifiedAgent,
_LastModifiedBy = item._LastModifiedBy,
_LastModifiedUtc = item._LastModifiedUtc,
productCode = item.ProductCode,
productId = item.ProductId,
productName = item.ProductName,
remark = item.ProductRemark,
quantity = item.Quantity,
stockPlanning = item.StockPlanning,
uomId = item.UomId,
uom = item.UomUnit,
}).ToList()
};
PropertyCopier <InventoryDocument, InventoryDocumentViewModel> .Copy(model, viewModel);
return(viewModel);
}
public InventoryDocument MapToModel(InventoryDocumentViewModel viewModel)
{
InventoryDocument model = new InventoryDocument
{
ReferenceNo = viewModel.referenceNo,
ReferenceType = viewModel.referenceType,
Remark = viewModel.remark,
StorageCode = viewModel.storageCode,
StorageId = Convert.ToInt32(viewModel.storageId),
StorageName = viewModel.storageName,
Date = viewModel.date,
Type = viewModel.type,
Items = viewModel.items.Select(item => new InventoryDocumentItem()
{
Id = item.Id,
Active = item.Active,
_CreatedAgent = item._CreatedAgent,
_CreatedBy = item._CreatedBy,
_CreatedUtc = item._CreatedUtc,
_IsDeleted = item._IsDeleted,
_LastModifiedAgent = item._LastModifiedAgent,
_LastModifiedBy = item._LastModifiedBy,
_LastModifiedUtc = item._LastModifiedUtc,
ProductCode = item.productCode,
ProductId = item.productId,
ProductName = item.productName,
ProductRemark = item.remark,
Quantity = item.quantity,
StockPlanning = item.stockPlanning,
UomId = item.uomId,
UomUnit = item.uom,
}).ToList()
};
PropertyCopier <InventoryDocumentViewModel, InventoryDocument> .Copy(viewModel, model);
return(model);
}
public override void UpdateNodes()
{
IncomingInvoice invoiceAlias = null;
IncomingWater waterAlias = null;
MovementDocument movementAlias = null;
WriteoffDocument writeoffAlias = null;
InventoryDocument inventoryAlias = null;
ShiftChangeWarehouseDocument shiftchangeAlias = null;
SelfDeliveryDocument selfDeliveryAlias = null;
RegradingOfGoodsDocument regradingOfGoodsAlias = null;
DocumentVMNode resultAlias = null;
Counterparty counterpartyAlias = null;
Counterparty secondCounterpartyAlias = null;
Warehouse warehouseAlias = null;
Warehouse secondWarehouseAlias = null;
MovementWagon wagonAlias = null;
Nomenclature productAlias = null;
CarLoadDocument loadCarAlias = null;
CarUnloadDocument unloadCarAlias = null;
RouteList routeListAlias = null;
Car carAlias = null;
Employee driverAlias = null;
Employee authorAlias = null;
Employee lastEditorAlias = null;
Domain.Orders.Order orderAlias = null;
List <DocumentVMNode> result = new List <DocumentVMNode> ();
if ((Filter.RestrictDocumentType == null || Filter.RestrictDocumentType == DocumentType.IncomingInvoice) && Filter.RestrictDriver == null)
{
var invoiceQuery = UoW.Session.QueryOver <IncomingInvoice>(() => invoiceAlias);
if (Filter.RestrictWarehouse != null)
{
invoiceQuery.Where(x => x.Warehouse.Id == Filter.RestrictWarehouse.Id);
}
if (Filter.RestrictStartDate.HasValue)
{
invoiceQuery.Where(o => o.TimeStamp >= Filter.RestrictStartDate.Value);
}
if (Filter.RestrictEndDate.HasValue)
{
invoiceQuery.Where(o => o.TimeStamp < Filter.RestrictEndDate.Value.AddDays(1));
}
var invoiceList = invoiceQuery.JoinQueryOver(() => invoiceAlias.Contractor, () => counterpartyAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin)
.JoinQueryOver(() => invoiceAlias.Warehouse, () => warehouseAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin)
.JoinAlias(() => invoiceAlias.Author, () => authorAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin)
.JoinAlias(() => invoiceAlias.LastEditor, () => lastEditorAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin)
.SelectList(list => list
.Select(() => invoiceAlias.Id).WithAlias(() => resultAlias.Id)
.Select(() => invoiceAlias.TimeStamp).WithAlias(() => resultAlias.Date)
.Select(() => invoiceAlias.Comment).WithAlias(() => resultAlias.Comment)
.Select(() => DocumentType.IncomingInvoice).WithAlias(() => resultAlias.DocTypeEnum)
.Select(Projections.Conditional(
Restrictions.Where(() => counterpartyAlias.Name == null),
Projections.Constant("Не указан", NHibernateUtil.String),
Projections.Property(() => counterpartyAlias.Name)))
.WithAlias(() => resultAlias.Counterparty)
.Select(Projections.Conditional(
Restrictions.Where(() => warehouseAlias.Name == null),
Projections.Constant("Не указан", NHibernateUtil.String),
Projections.Property(() => warehouseAlias.Name)))
.WithAlias(() => resultAlias.Warehouse)
.Select(() => authorAlias.LastName).WithAlias(() => resultAlias.AuthorSurname)
.Select(() => authorAlias.Name).WithAlias(() => resultAlias.AuthorName)
.Select(() => authorAlias.Patronymic).WithAlias(() => resultAlias.AuthorPatronymic)
.Select(() => lastEditorAlias.LastName).WithAlias(() => resultAlias.LastEditorSurname)
.Select(() => lastEditorAlias.Name).WithAlias(() => resultAlias.LastEditorName)
.Select(() => lastEditorAlias.Patronymic).WithAlias(() => resultAlias.LastEditorPatronymic)
.Select(() => invoiceAlias.LastEditedTime).WithAlias(() => resultAlias.LastEditedTime)
)
.TransformUsing(Transformers.AliasToBean <DocumentVMNode> ())
.List <DocumentVMNode> ();
result.AddRange(invoiceList);
}
if ((Filter.RestrictDocumentType == null || Filter.RestrictDocumentType == DocumentType.IncomingWater) && Filter.RestrictDriver == null)
{
var waterQuery = UoW.Session.QueryOver <IncomingWater>(() => waterAlias);
if (Filter.RestrictWarehouse != null)
{
waterQuery.Where(x => x.IncomingWarehouse.Id == Filter.RestrictWarehouse.Id || x.WriteOffWarehouse.Id == Filter.RestrictWarehouse.Id);
}
if (Filter.RestrictStartDate.HasValue)
{
waterQuery.Where(o => o.TimeStamp >= Filter.RestrictStartDate.Value);
}
if (Filter.RestrictEndDate.HasValue)
{
waterQuery.Where(o => o.TimeStamp < Filter.RestrictEndDate.Value.AddDays(1));
}
var waterList = waterQuery
.JoinQueryOver(() => waterAlias.IncomingWarehouse, () => warehouseAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin)
.JoinAlias(() => waterAlias.Author, () => authorAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin)
.JoinAlias(() => waterAlias.LastEditor, () => lastEditorAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin)
.Left.JoinAlias(() => waterAlias.Product, () => productAlias)
.SelectList(list => list
.Select(() => waterAlias.Id).WithAlias(() => resultAlias.Id)
.Select(() => waterAlias.TimeStamp).WithAlias(() => resultAlias.Date)
.Select(() => DocumentType.IncomingWater).WithAlias(() => resultAlias.DocTypeEnum)
.Select(Projections.Conditional(
Restrictions.Where(() => warehouseAlias.Name == null),
Projections.Constant("Не указан", NHibernateUtil.String),
Projections.Property(() => warehouseAlias.Name)))
.WithAlias(() => resultAlias.Warehouse)
.Select(() => productAlias.Name).WithAlias(() => resultAlias.ProductName)
.Select(() => waterAlias.Amount).WithAlias(() => resultAlias.Amount)
.Select(() => authorAlias.LastName).WithAlias(() => resultAlias.AuthorSurname)
.Select(() => authorAlias.Name).WithAlias(() => resultAlias.AuthorName)
.Select(() => authorAlias.Patronymic).WithAlias(() => resultAlias.AuthorPatronymic)
.Select(() => lastEditorAlias.LastName).WithAlias(() => resultAlias.LastEditorSurname)
.Select(() => lastEditorAlias.Name).WithAlias(() => resultAlias.LastEditorName)
.Select(() => lastEditorAlias.Patronymic).WithAlias(() => resultAlias.LastEditorPatronymic)
.Select(() => waterAlias.LastEditedTime).WithAlias(() => resultAlias.LastEditedTime))
.TransformUsing(Transformers.AliasToBean <DocumentVMNode> ())
.List <DocumentVMNode> ();
result.AddRange(waterList);
}
if ((Filter.RestrictDocumentType == null || Filter.RestrictDocumentType == DocumentType.MovementDocument) && Filter.RestrictDriver == null)
{
var movementQuery = UoW.Session.QueryOver <MovementDocument>(() => movementAlias);
if (Filter.RestrictWarehouse != null)
{
movementQuery.Where(x => x.FromWarehouse.Id == Filter.RestrictWarehouse.Id || x.ToWarehouse.Id == Filter.RestrictWarehouse.Id);
}
if (Filter.RestrictStartDate.HasValue)
{
movementQuery.Where(o => o.TimeStamp >= Filter.RestrictStartDate.Value);
}
if (Filter.RestrictEndDate.HasValue)
{
movementQuery.Where(o => o.TimeStamp < Filter.RestrictEndDate.Value.AddDays(1));
}
if (Filter.RestrictMovementStatus.HasValue && Filter.RestrictDocumentType == DocumentType.MovementDocument)
{
movementQuery.Where(o => o.Status == Filter.RestrictMovementStatus.Value);
}
var movementList = movementQuery
.JoinQueryOver(() => movementAlias.FromWarehouse, () => warehouseAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin)
.JoinQueryOver(() => movementAlias.ToWarehouse, () => secondWarehouseAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin)
.JoinAlias(() => movementAlias.MovementWagon, () => wagonAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin)
.JoinAlias(() => movementAlias.Author, () => authorAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin)
.JoinAlias(() => movementAlias.LastEditor, () => lastEditorAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin)
.SelectList(list => list
.Select(() => movementAlias.Id).WithAlias(() => resultAlias.Id)
.Select(() => movementAlias.TimeStamp).WithAlias(() => resultAlias.Date)
.Select(() => DocumentType.MovementDocument).WithAlias(() => resultAlias.DocTypeEnum)
.Select(() => movementAlias.Status).WithAlias(() => resultAlias.MovementDocumentStatus)
.Select(() => movementAlias.HasDiscrepancy).WithAlias(() => resultAlias.MovementDocumentDiscrepancy)
.Select(() => wagonAlias.Name).WithAlias(() => resultAlias.CarNumber)
.Select(Projections.Conditional(
Restrictions.Where(() => warehouseAlias.Name == null),
Projections.Constant("Не указан", NHibernateUtil.String),
Projections.Property(() => warehouseAlias.Name)))
.WithAlias(() => resultAlias.Warehouse)
.Select(Projections.Conditional(
Restrictions.Where(() => secondWarehouseAlias.Name == null),
Projections.Constant("Не указан", NHibernateUtil.String),
Projections.Property(() => secondWarehouseAlias.Name)))
.WithAlias(() => resultAlias.SecondWarehouse)
.Select(() => authorAlias.LastName).WithAlias(() => resultAlias.AuthorSurname)
.Select(() => authorAlias.Name).WithAlias(() => resultAlias.AuthorName)
.Select(() => authorAlias.Patronymic).WithAlias(() => resultAlias.AuthorPatronymic)
.Select(() => lastEditorAlias.LastName).WithAlias(() => resultAlias.LastEditorSurname)
.Select(() => lastEditorAlias.Name).WithAlias(() => resultAlias.LastEditorName)
.Select(() => lastEditorAlias.Patronymic).WithAlias(() => resultAlias.LastEditorPatronymic)
.Select(() => movementAlias.LastEditedTime).WithAlias(() => resultAlias.LastEditedTime))
.TransformUsing(Transformers.AliasToBean <DocumentVMNode> ())
.List <DocumentVMNode> ();
result.AddRange(movementList);
}
if ((Filter.RestrictDocumentType == null || Filter.RestrictDocumentType == DocumentType.WriteoffDocument) && Filter.RestrictDriver == null)
{
var writeoffQuery = UoW.Session.QueryOver <WriteoffDocument>(() => writeoffAlias);
if (Filter.RestrictWarehouse != null)
{
writeoffQuery.Where(x => x.WriteoffWarehouse.Id == Filter.RestrictWarehouse.Id);
}
if (Filter.RestrictStartDate.HasValue)
{
writeoffQuery.Where(o => o.TimeStamp >= Filter.RestrictStartDate.Value);
}
if (Filter.RestrictEndDate.HasValue)
{
writeoffQuery.Where(o => o.TimeStamp < Filter.RestrictEndDate.Value.AddDays(1));
}
var writeoffList = writeoffQuery
.JoinQueryOver(() => writeoffAlias.Client, () => counterpartyAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin)
.JoinQueryOver(() => writeoffAlias.WriteoffWarehouse, () => warehouseAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin)
.JoinAlias(() => writeoffAlias.Author, () => authorAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin)
.JoinAlias(() => writeoffAlias.LastEditor, () => lastEditorAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin)
.SelectList(list => list
.Select(() => writeoffAlias.Id).WithAlias(() => resultAlias.Id)
.Select(() => writeoffAlias.TimeStamp).WithAlias(() => resultAlias.Date)
.Select(() => DocumentType.WriteoffDocument).WithAlias(() => resultAlias.DocTypeEnum)
.Select(Projections.Conditional(
Restrictions.Where(() => counterpartyAlias.Name == null),
Projections.Constant(string.Empty, NHibernateUtil.String),
Projections.Property(() => counterpartyAlias.Name)))
.WithAlias(() => resultAlias.Counterparty)
.Select(Projections.Conditional(
Restrictions.Where(() => warehouseAlias.Name == null),
Projections.Constant(string.Empty, NHibernateUtil.String),
Projections.Property(() => warehouseAlias.Name)))
.WithAlias(() => resultAlias.Warehouse)
.Select(() => authorAlias.LastName).WithAlias(() => resultAlias.AuthorSurname)
.Select(() => authorAlias.Name).WithAlias(() => resultAlias.AuthorName)
.Select(() => authorAlias.Patronymic).WithAlias(() => resultAlias.AuthorPatronymic)
.Select(() => lastEditorAlias.LastName).WithAlias(() => resultAlias.LastEditorSurname)
.Select(() => lastEditorAlias.Name).WithAlias(() => resultAlias.LastEditorName)
.Select(() => lastEditorAlias.Patronymic).WithAlias(() => resultAlias.LastEditorPatronymic)
.Select(() => writeoffAlias.LastEditedTime).WithAlias(() => resultAlias.LastEditedTime))
.TransformUsing(Transformers.AliasToBean <DocumentVMNode> ())
.List <DocumentVMNode> ();
result.AddRange(writeoffList);
}
if ((Filter.RestrictDocumentType == null || Filter.RestrictDocumentType == DocumentType.InventoryDocument) && Filter.RestrictDriver == null)
{
var inventoryQuery = UoW.Session.QueryOver <InventoryDocument>(() => inventoryAlias);
if (Filter.RestrictWarehouse != null)
{
inventoryQuery.Where(x => x.Warehouse.Id == Filter.RestrictWarehouse.Id);
}
if (Filter.RestrictStartDate.HasValue)
{
inventoryQuery.Where(o => o.TimeStamp >= Filter.RestrictStartDate.Value);
}
if (Filter.RestrictEndDate.HasValue)
{
inventoryQuery.Where(o => o.TimeStamp < Filter.RestrictEndDate.Value.AddDays(1));
}
var inventoryList = inventoryQuery
.JoinQueryOver(() => inventoryAlias.Warehouse, () => warehouseAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin)
.JoinAlias(() => inventoryAlias.Author, () => authorAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin)
.JoinAlias(() => inventoryAlias.LastEditor, () => lastEditorAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin)
.SelectList(list => list
.Select(() => inventoryAlias.Id).WithAlias(() => resultAlias.Id)
.Select(() => inventoryAlias.TimeStamp).WithAlias(() => resultAlias.Date)
.Select(() => DocumentType.InventoryDocument).WithAlias(() => resultAlias.DocTypeEnum)
.Select(() => warehouseAlias.Name).WithAlias(() => resultAlias.Warehouse)
.Select(() => authorAlias.LastName).WithAlias(() => resultAlias.AuthorSurname)
.Select(() => authorAlias.Name).WithAlias(() => resultAlias.AuthorName)
.Select(() => authorAlias.Patronymic).WithAlias(() => resultAlias.AuthorPatronymic)
.Select(() => lastEditorAlias.LastName).WithAlias(() => resultAlias.LastEditorSurname)
.Select(() => lastEditorAlias.Name).WithAlias(() => resultAlias.LastEditorName)
.Select(() => lastEditorAlias.Patronymic).WithAlias(() => resultAlias.LastEditorPatronymic)
.Select(() => inventoryAlias.LastEditedTime).WithAlias(() => resultAlias.LastEditedTime))
.TransformUsing(Transformers.AliasToBean <DocumentVMNode> ())
.List <DocumentVMNode> ();
result.AddRange(inventoryList);
}
if ((Filter.RestrictDocumentType == null || Filter.RestrictDocumentType == DocumentType.ShiftChangeDocument) && Filter.RestrictDriver == null)
{
var shiftchangeQuery = UoW.Session.QueryOver <ShiftChangeWarehouseDocument>(() => shiftchangeAlias);
if (Filter.RestrictWarehouse != null)
{
shiftchangeQuery.Where(x => x.Warehouse.Id == Filter.RestrictWarehouse.Id);
}
if (Filter.RestrictStartDate.HasValue)
{
shiftchangeQuery.Where(o => o.TimeStamp >= Filter.RestrictStartDate.Value);
}
if (Filter.RestrictEndDate.HasValue)
{
shiftchangeQuery.Where(o => o.TimeStamp < Filter.RestrictEndDate.Value.AddDays(1));
}
var shiftchangeList = shiftchangeQuery
.JoinQueryOver(() => shiftchangeAlias.Warehouse, () => warehouseAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin)
.JoinAlias(() => shiftchangeAlias.Author, () => authorAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin)
.JoinAlias(() => shiftchangeAlias.LastEditor, () => lastEditorAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin)
.SelectList(list => list
.Select(() => shiftchangeAlias.Id).WithAlias(() => resultAlias.Id)
.Select(() => shiftchangeAlias.TimeStamp).WithAlias(() => resultAlias.Date)
.Select(() => DocumentType.ShiftChangeDocument).WithAlias(() => resultAlias.DocTypeEnum)
.Select(() => warehouseAlias.Name).WithAlias(() => resultAlias.Warehouse)
.Select(() => authorAlias.LastName).WithAlias(() => resultAlias.AuthorSurname)
.Select(() => authorAlias.Name).WithAlias(() => resultAlias.AuthorName)
.Select(() => authorAlias.Patronymic).WithAlias(() => resultAlias.AuthorPatronymic)
.Select(() => lastEditorAlias.LastName).WithAlias(() => resultAlias.LastEditorSurname)
.Select(() => lastEditorAlias.Name).WithAlias(() => resultAlias.LastEditorName)
.Select(() => lastEditorAlias.Patronymic).WithAlias(() => resultAlias.LastEditorPatronymic)
.Select(() => shiftchangeAlias.LastEditedTime).WithAlias(() => resultAlias.LastEditedTime))
.TransformUsing(Transformers.AliasToBean <DocumentVMNode>())
.List <DocumentVMNode>();
result.AddRange(shiftchangeList);
}
if ((Filter.RestrictDocumentType == null || Filter.RestrictDocumentType == DocumentType.RegradingOfGoodsDocument) && Filter.RestrictDriver == null)
{
var regrandingQuery = UoW.Session.QueryOver <RegradingOfGoodsDocument>(() => regradingOfGoodsAlias);
if (Filter.RestrictWarehouse != null)
{
regrandingQuery.Where(x => x.Warehouse.Id == Filter.RestrictWarehouse.Id);
}
if (Filter.RestrictStartDate.HasValue)
{
regrandingQuery.Where(o => o.TimeStamp >= Filter.RestrictStartDate.Value);
}
if (Filter.RestrictEndDate.HasValue)
{
regrandingQuery.Where(o => o.TimeStamp < Filter.RestrictEndDate.Value.AddDays(1));
}
var regrandingList = regrandingQuery
.JoinQueryOver(() => regradingOfGoodsAlias.Warehouse, () => warehouseAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin)
.JoinAlias(() => regradingOfGoodsAlias.Author, () => authorAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin)
.JoinAlias(() => regradingOfGoodsAlias.LastEditor, () => lastEditorAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin)
.SelectList(list => list
.Select(() => regradingOfGoodsAlias.Id).WithAlias(() => resultAlias.Id)
.Select(() => regradingOfGoodsAlias.TimeStamp).WithAlias(() => resultAlias.Date)
.Select(() => DocumentType.RegradingOfGoodsDocument).WithAlias(() => resultAlias.DocTypeEnum)
.Select(() => warehouseAlias.Name).WithAlias(() => resultAlias.Warehouse)
.Select(() => authorAlias.LastName).WithAlias(() => resultAlias.AuthorSurname)
.Select(() => authorAlias.Name).WithAlias(() => resultAlias.AuthorName)
.Select(() => authorAlias.Patronymic).WithAlias(() => resultAlias.AuthorPatronymic)
.Select(() => lastEditorAlias.LastName).WithAlias(() => resultAlias.LastEditorSurname)
.Select(() => lastEditorAlias.Name).WithAlias(() => resultAlias.LastEditorName)
.Select(() => lastEditorAlias.Patronymic).WithAlias(() => resultAlias.LastEditorPatronymic)
.Select(() => regradingOfGoodsAlias.LastEditedTime).WithAlias(() => resultAlias.LastEditedTime))
.TransformUsing(Transformers.AliasToBean <DocumentVMNode> ())
.List <DocumentVMNode> ();
result.AddRange(regrandingList);
}
if ((Filter.RestrictDocumentType == null || Filter.RestrictDocumentType == DocumentType.SelfDeliveryDocument) && Filter.RestrictDriver == null)
{
var selfDeliveryQuery = UoW.Session.QueryOver <SelfDeliveryDocument>(() => selfDeliveryAlias)
.JoinQueryOver(() => selfDeliveryAlias.Warehouse, () => warehouseAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin)
.JoinQueryOver(() => selfDeliveryAlias.Order, () => orderAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin)
.JoinQueryOver(() => orderAlias.Client, () => counterpartyAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin);
if (Filter.RestrictWarehouse != null)
{
selfDeliveryQuery.Where(() => selfDeliveryAlias.Warehouse.Id == Filter.RestrictWarehouse.Id);
}
if (Filter.RestrictStartDate.HasValue)
{
selfDeliveryQuery.Where(() => selfDeliveryAlias.TimeStamp >= Filter.RestrictStartDate.Value);
}
if (Filter.RestrictEndDate.HasValue)
{
selfDeliveryQuery.Where(() => selfDeliveryAlias.TimeStamp < Filter.RestrictEndDate.Value.AddDays(1));
}
var selfDeliveryList = selfDeliveryQuery
.JoinAlias(() => selfDeliveryAlias.Author, () => authorAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin)
.JoinAlias(() => selfDeliveryAlias.LastEditor, () => lastEditorAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin)
.SelectList(list => list
.Select(() => selfDeliveryAlias.Id).WithAlias(() => resultAlias.Id)
.Select(() => orderAlias.Id).WithAlias(() => resultAlias.OrderId)
.Select(() => selfDeliveryAlias.TimeStamp).WithAlias(() => resultAlias.Date)
.Select(() => DocumentType.SelfDeliveryDocument).WithAlias(() => resultAlias.DocTypeEnum)
.Select(() => counterpartyAlias.Name).WithAlias(() => resultAlias.Counterparty)
.Select(() => warehouseAlias.Name).WithAlias(() => resultAlias.Warehouse)
.Select(() => authorAlias.LastName).WithAlias(() => resultAlias.AuthorSurname)
.Select(() => authorAlias.Name).WithAlias(() => resultAlias.AuthorName)
.Select(() => authorAlias.Patronymic).WithAlias(() => resultAlias.AuthorPatronymic)
.Select(() => lastEditorAlias.LastName).WithAlias(() => resultAlias.LastEditorSurname)
.Select(() => lastEditorAlias.Name).WithAlias(() => resultAlias.LastEditorName)
.Select(() => lastEditorAlias.Patronymic).WithAlias(() => resultAlias.LastEditorPatronymic)
.Select(() => selfDeliveryAlias.LastEditedTime).WithAlias(() => resultAlias.LastEditedTime))
.TransformUsing(Transformers.AliasToBean <DocumentVMNode> ())
.List <DocumentVMNode> ();
result.AddRange(selfDeliveryList);
}
if (Filter.RestrictDocumentType == null || Filter.RestrictDocumentType == DocumentType.CarLoadDocument)
{
var carLoadQuery = UoW.Session.QueryOver <CarLoadDocument>(() => loadCarAlias)
.JoinQueryOver(() => loadCarAlias.Warehouse, () => warehouseAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin)
.JoinQueryOver(() => loadCarAlias.RouteList, () => routeListAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin)
.JoinQueryOver(() => routeListAlias.Car, () => carAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin)
.JoinQueryOver(() => routeListAlias.Driver, () => driverAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin);
if (Filter.RestrictWarehouse != null)
{
carLoadQuery.Where(() => loadCarAlias.Warehouse.Id == Filter.RestrictWarehouse.Id);
}
if (Filter.RestrictStartDate.HasValue)
{
carLoadQuery.Where(() => loadCarAlias.TimeStamp >= Filter.RestrictStartDate.Value);
}
if (Filter.RestrictEndDate.HasValue)
{
carLoadQuery.Where(() => loadCarAlias.TimeStamp < Filter.RestrictEndDate.Value.AddDays(1));
}
if (Filter.RestrictDriver != null)
{
carLoadQuery.Where(() => routeListAlias.Driver.Id == Filter.RestrictDriver.Id);
}
var carLoadList = carLoadQuery
.JoinAlias(() => loadCarAlias.Author, () => authorAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin)
.JoinAlias(() => loadCarAlias.LastEditor, () => lastEditorAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin)
.SelectList(list => list
.Select(() => loadCarAlias.Id).WithAlias(() => resultAlias.Id)
.Select(() => loadCarAlias.TimeStamp).WithAlias(() => resultAlias.Date)
.Select(() => DocumentType.CarLoadDocument).WithAlias(() => resultAlias.DocTypeEnum)
.Select(() => carAlias.Model).WithAlias(() => resultAlias.CarModel)
.Select(() => carAlias.RegistrationNumber).WithAlias(() => resultAlias.CarNumber)
.Select(() => driverAlias.LastName).WithAlias(() => resultAlias.DirverSurname)
.Select(() => driverAlias.Name).WithAlias(() => resultAlias.DirverName)
.Select(() => driverAlias.Patronymic).WithAlias(() => resultAlias.DirverPatronymic)
.Select(() => warehouseAlias.Name).WithAlias(() => resultAlias.Warehouse)
.Select(() => routeListAlias.Id).WithAlias(() => resultAlias.RouteListId)
.Select(() => authorAlias.LastName).WithAlias(() => resultAlias.AuthorSurname)
.Select(() => authorAlias.Name).WithAlias(() => resultAlias.AuthorName)
.Select(() => authorAlias.Patronymic).WithAlias(() => resultAlias.AuthorPatronymic)
.Select(() => lastEditorAlias.LastName).WithAlias(() => resultAlias.LastEditorSurname)
.Select(() => lastEditorAlias.Name).WithAlias(() => resultAlias.LastEditorName)
.Select(() => lastEditorAlias.Patronymic).WithAlias(() => resultAlias.LastEditorPatronymic)
.Select(() => loadCarAlias.LastEditedTime).WithAlias(() => resultAlias.LastEditedTime))
.TransformUsing(Transformers.AliasToBean <DocumentVMNode> ())
.List <DocumentVMNode> ();
result.AddRange(carLoadList);
}
if (Filter.RestrictDocumentType == null || Filter.RestrictDocumentType == DocumentType.CarUnloadDocument)
{
var carUnloadQuery = UoW.Session.QueryOver <CarUnloadDocument>(() => unloadCarAlias)
.JoinQueryOver(() => unloadCarAlias.Warehouse, () => warehouseAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin)
.JoinQueryOver(() => unloadCarAlias.RouteList, () => routeListAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin)
.JoinQueryOver(() => routeListAlias.Car, () => carAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin)
.JoinQueryOver(() => routeListAlias.Driver, () => driverAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin);
if (Filter.RestrictWarehouse != null)
{
carUnloadQuery.Where(() => unloadCarAlias.Warehouse.Id == Filter.RestrictWarehouse.Id);
}
if (Filter.RestrictStartDate.HasValue)
{
carUnloadQuery.Where(() => unloadCarAlias.TimeStamp >= Filter.RestrictStartDate.Value);
}
if (Filter.RestrictEndDate.HasValue)
{
carUnloadQuery.Where(() => unloadCarAlias.TimeStamp < Filter.RestrictEndDate.Value.AddDays(1));
}
if (Filter.RestrictDriver != null)
{
carUnloadQuery.Where(() => routeListAlias.Driver.Id == Filter.RestrictDriver.Id);
}
var carUnloadList = carUnloadQuery
.JoinAlias(() => unloadCarAlias.Author, () => authorAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin)
.JoinAlias(() => unloadCarAlias.LastEditor, () => lastEditorAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin)
.SelectList(list => list
.Select(() => unloadCarAlias.Id).WithAlias(() => resultAlias.Id)
.Select(() => unloadCarAlias.TimeStamp).WithAlias(() => resultAlias.Date)
.Select(() => DocumentType.CarUnloadDocument).WithAlias(() => resultAlias.DocTypeEnum)
.Select(() => carAlias.Model).WithAlias(() => resultAlias.CarModel)
.Select(() => carAlias.RegistrationNumber).WithAlias(() => resultAlias.CarNumber)
.Select(() => driverAlias.LastName).WithAlias(() => resultAlias.DirverSurname)
.Select(() => driverAlias.Name).WithAlias(() => resultAlias.DirverName)
.Select(() => driverAlias.Patronymic).WithAlias(() => resultAlias.DirverPatronymic)
.Select(() => warehouseAlias.Name).WithAlias(() => resultAlias.Warehouse)
.Select(() => routeListAlias.Id).WithAlias(() => resultAlias.RouteListId)
.Select(() => authorAlias.LastName).WithAlias(() => resultAlias.AuthorSurname)
.Select(() => authorAlias.Name).WithAlias(() => resultAlias.AuthorName)
.Select(() => authorAlias.Patronymic).WithAlias(() => resultAlias.AuthorPatronymic)
.Select(() => lastEditorAlias.LastName).WithAlias(() => resultAlias.LastEditorSurname)
.Select(() => lastEditorAlias.Name).WithAlias(() => resultAlias.LastEditorName)
.Select(() => lastEditorAlias.Patronymic).WithAlias(() => resultAlias.LastEditorPatronymic)
.Select(() => unloadCarAlias.LastEditedTime).WithAlias(() => resultAlias.LastEditedTime))
.TransformUsing(Transformers.AliasToBean <DocumentVMNode> ())
.List <DocumentVMNode> ();
result.AddRange(carUnloadList);
}
result.Sort((x, y) => {
if (x.Date < y.Date)
{
return(1);
}
if (x.Date == y.Date)
{
return(0);
}
return(-1);
});
SetItemsSource(result);
}
public InventorySheets(InventoryDocument parent)
: base(parent, "sheet")
{
}
public static Document DeserializeRelatedDocument(DocumentRelation relation, XElement relatedDocument)
{
Document parent = (Document)relation.Parent;
DocumentRelationType relationType = relation.RelationType;
Document retDocument = null;
if (relatedDocument == null)
{
throw new ClientException(ClientExceptionId.IncompleteRelation);
}
switch (relationType)
{
case DocumentRelationType.SalesDocumentToSimulatedInvoice:
case DocumentRelationType.InvoiceToBill:
retDocument = new CommercialDocument();
retDocument.Deserialize(relatedDocument);
break;
case DocumentRelationType.ServiceToOutcomeShift:
if (parent.BOType == BusinessObjectType.ServiceDocument)
{
retDocument = new WarehouseDocument();
retDocument.Deserialize(relatedDocument);
}
else
{
retDocument = new ServiceDocument();
retDocument.Deserialize(relatedDocument);
}
break;
case DocumentRelationType.ServiceToInvoice:
if (parent.BOType == BusinessObjectType.ServiceDocument)
{
retDocument = new CommercialDocument();
retDocument.Deserialize(relatedDocument);
}
else
{
retDocument = new ServiceDocument();
retDocument.Deserialize(relatedDocument);
}
break;
case DocumentRelationType.ServiceToInternalOutcome:
if (parent.BOType == BusinessObjectType.ServiceDocument)
{
retDocument = new WarehouseDocument();
retDocument.Deserialize(relatedDocument);
}
else
{
retDocument = new ServiceDocument();
retDocument.Deserialize(relatedDocument);
}
break;
case DocumentRelationType.ComplaintToInternalOutcome:
if (parent.BOType == BusinessObjectType.ComplaintDocument)
{
retDocument = new WarehouseDocument();
retDocument.Deserialize(relatedDocument);
}
else
{
retDocument = new ComplaintDocument();
retDocument.Deserialize(relatedDocument);
}
break;
case DocumentRelationType.InventoryToWarehouse:
if (parent.BOType == BusinessObjectType.InventoryDocument)
{
retDocument = new WarehouseDocument();
retDocument.Deserialize(relatedDocument);
}
else
{
retDocument = new InventoryDocument();
retDocument.Deserialize(relatedDocument);
}
break;
case DocumentRelationType.SalesOrderToInvoice:
case DocumentRelationType.SalesOrderToCorrectiveCommercialDocument:
case DocumentRelationType.SalesOrderToSimulatedInvoice:
retDocument = new CommercialDocument();
retDocument.Deserialize(relatedDocument);
break;
case DocumentRelationType.SalesOrderToWarehouseDocument:
if (parent.BOType == BusinessObjectType.CommercialDocument)
{
retDocument = new WarehouseDocument();
retDocument.Deserialize(relatedDocument);
}
else
{
retDocument = new CommercialDocument();
retDocument.Deserialize(relatedDocument);
}
break;
case DocumentRelationType.SalesOrderToOutcomeFinancialDocument:
if (parent.BOType == BusinessObjectType.CommercialDocument)
{
retDocument = new FinancialDocument();
retDocument.Deserialize(relatedDocument);
}
else
{
retDocument = new CommercialDocument();
retDocument.Deserialize(relatedDocument);
}
break;
case DocumentRelationType.ProductionOrderToIncome:
case DocumentRelationType.ProductionOrderToOutcome:
if (parent.BOType == BusinessObjectType.CommercialDocument)
{
retDocument = new WarehouseDocument();
retDocument.Deserialize(relatedDocument);
}
else
{
retDocument = new CommercialDocument();
retDocument.Deserialize(relatedDocument);
}
break;
default:
throw new InvalidOperationException("Unknown DocumentRelationType");
}
return(retDocument);
}
/// <summary>
/// Saves the business object.
/// </summary>
/// <param name="document"><see cref="CommercialDocument"/> to save.</param>
/// <returns>Xml containing result of oper</returns>
public XDocument SaveBusinessObject(InventoryDocument document)
{
DictionaryMapper.Instance.CheckForChanges();
//load alternate version
if (!document.IsNew)
{
IBusinessObject alternateBusinessObject = this.mapper.LoadBusinessObject(document.BOType, document.Id.Value);
document.SetAlternateVersion(alternateBusinessObject);
}
foreach (var sheet in document.Sheets)
{
sheet.SkipLinesSave = true;
InventorySheet alternateSheet = sheet.AlternateVersion as InventorySheet;
if (alternateSheet != null && alternateSheet.DocumentStatus != sheet.DocumentStatus && sheet.DocumentStatus == DocumentStatus.Canceled)
{
//jezeli anulowalismy arkusz z poziomu inwentaryzacji to nalezy caly arkusz wczytac, zmienic jego status i dodac do zapisu zeby
//wykonala sie tez inna jego logika zwiazana ze zmiana statusu
InventorySheet sh = (InventorySheet)this.mapper.LoadBusinessObject(BusinessObjectType.InventorySheet, sheet.Id.Value);
sh.DocumentStatus = DocumentStatus.Canceled;
document.AddRelatedObject(sh);
}
}
//update status
document.UpdateStatus(true);
if (document.AlternateVersion != null)
{
document.AlternateVersion.UpdateStatus(false);
}
document.Validate();
this.ExecuteCustomLogic(document);
this.ExecuteDocumentOptions(document);
//validate
document.Validate();
//update status
document.UpdateStatus(true);
if (document.AlternateVersion != null)
{
document.AlternateVersion.UpdateStatus(false);
}
SqlConnectionManager.Instance.BeginTransaction();
try
{
DictionaryMapper.Instance.CheckForChanges();
this.mapper.CheckBusinessObjectVersion(document);
DocumentLogicHelper.AssignNumber(document, this.mapper);
//Make operations list
XDocument operations = XDocument.Parse("<root/>");
document.SaveChanges(operations);
if (document.AlternateVersion != null)
{
document.AlternateVersion.SaveChanges(operations);
}
if (operations.Root.HasElements)
{
this.mapper.ExecuteOperations(operations);
if (document.DocumentStatus == DocumentStatus.Committed)
{
this.mapper.CreateCommunicationXml(document);
}
this.mapper.UpdateDictionaryIndex(document);
}
Coordinator.LogSaveBusinessObjectOperation();
foreach (var sheet in document.SheetsToSave)
{
using (DocumentCoordinator c = new DocumentCoordinator(false, false))
{
c.SaveBusinessObject(sheet);
}
}
if (document.UnblockItems)
{
this.itemMapper.UnblockItems();
}
document.SaveRelatedObjects();
operations = XDocument.Parse("<root/>");
document.SaveRelations(operations);
if (document.AlternateVersion != null)
{
((InventoryDocument)document.AlternateVersion).SaveRelations(operations);
}
if (operations.Root.HasElements)
{
this.mapper.ExecuteOperations(operations);
}
if (operations.Root.HasElements)
{
this.mapper.CreateCommunicationXmlForDocumentRelations(operations); //generowanie paczek dla relacji dokumentow
}
XDocument returnXml = XDocument.Parse(String.Format(CultureInfo.InvariantCulture, "<root><id>{0}</id></root>", document.Id.ToUpperString()));
//Custom validation
this.mapper.ExecuteOnCommitValidationCustomProcedure(document);
if (this.coordinator.CanCommitTransaction)
{
if (!ConfigurationMapper.Instance.ForceRollbackTransaction)
{
SqlConnectionManager.Instance.CommitTransaction();
}
else
{
SqlConnectionManager.Instance.RollbackTransaction();
}
}
return(returnXml);
}
catch (SqlException sqle)
{
RoboFramework.Tools.RandomLogHelper.GetLog().Debug("FractusRefactorTraceCatch:72");
Coordinator.ProcessSqlException(sqle, document.BOType, this.coordinator.CanCommitTransaction);
throw;
}
catch (Exception)
{
RoboFramework.Tools.RandomLogHelper.GetLog().Debug("FractusRefactorTraceCatch:73");
if (this.coordinator.CanCommitTransaction)
{
SqlConnectionManager.Instance.RollbackTransaction();
}
throw;
}
}
private void ExecuteCustomLogic(InventoryDocument document)
{
InventoryDocument alternateDocument = document.AlternateVersion as InventoryDocument;
if (alternateDocument != null)
{
if (alternateDocument.DocumentStatus == DocumentStatus.Saved &&
(document.DocumentStatus == DocumentStatus.Committed || document.DocumentStatus == DocumentStatus.Canceled))
{
//wczytujemy wszystkie arkusze
foreach (InventorySheet s in document.Sheets)
{
InventorySheet sheet = (InventorySheet)this.mapper.LoadBusinessObject(BusinessObjectType.InventorySheet, s.Id.Value);
if (sheet.DocumentStatus == DocumentStatus.Saved)
{
sheet.DocumentStatus = document.DocumentStatus;
sheet.SkipItemsUnblock = true;
document.SheetsToSave.Add(sheet);
}
}
document.UnblockItems = true;
if (document.DocumentStatus == DocumentStatus.Committed)
{
var whDocs = InventoryDocumentFactory.GenerateDifferentialDocuments(document, document.SheetsToSave);
foreach (var whDoc in whDocs)
{
//Wycena pozycji przychodowych na podstawie ceny ostatniego zakupu
//Zrobiłem tak bo nie znam kernela a nie mamy obecnie kernelowca
if (whDoc.WarehouseDirection == WarehouseDirection.Income)
{
XDocument par = new XDocument(new XElement("root",
new XElement("warehouseId", whDoc.WarehouseId.ToString()),
whDoc.Lines.Serialize()));
XDocument priceList = null;
decimal headerSumation = 0;
priceList = new XDocument(this.mapper.ExecuteCustomProcedure("document.p_getWarehouseStock", true, par, true, 120, "xml"));
foreach (var item in whDoc.Lines)
{
decimal lastPrice;
lastPrice = decimal.Parse(
(from i in priceList.Descendants("line")
where i.Element("itemId").Value.ToLower() == item.ItemId.ToString().ToLower()
select i.Element("lastPurchaseNetPrice").Value).FirstOrDefault().Replace(".", ",")
);
item.Value = lastPrice * item.Quantity;
item.Price = lastPrice;
headerSumation = headerSumation + (lastPrice * item.Quantity);
}
whDoc.Value = headerSumation;
}
document.AddRelatedObject(whDoc);
DocumentRelation relation = document.Relations.CreateNew();
relation.RelationType = DocumentRelationType.InventoryToWarehouse;
relation.RelatedDocument = whDoc;
relation = whDoc.Relations.CreateNew();
relation.RelationType = DocumentRelationType.InventoryToWarehouse;
relation.RelatedDocument = document;
relation.DontSave = true;
}
}
}
}
}
public async Task <int> CreateInventoryDocumentAsync(FPReturnInvToPurchasing model, string Type)
{
string storageURI = "master/storages";
string uomURI = "master/uoms";
IHttpService httpClient = (IHttpService)this.ServiceProvider.GetService(typeof(IHttpService));
#region UOM
Dictionary <string, object> filterUOM = new Dictionary <string, object> {
{ "unit", "MTR" }
};
var responseUOM = httpClient.GetAsync($@"{APIEndpoint.Core}{uomURI}?filter=" + JsonConvert.SerializeObject(filterUOM)).Result.Content.ReadAsStringAsync();
Dictionary <string, object> resultUOM = JsonConvert.DeserializeObject <Dictionary <string, object> >(responseUOM.Result);
var jsonUOM = resultUOM.Single(p => p.Key.Equals("data")).Value;
Dictionary <string, object> uom = JsonConvert.DeserializeObject <List <Dictionary <string, object> > >(jsonUOM.ToString())[0];
#endregion UOM
#region Storage
var storageName = model.UnitName.Equals("PRINTING") ? "Gudang Greige Printing" : "Gudang Greige Finishing";
Dictionary <string, object> filterStorage = new Dictionary <string, object> {
{ "name", storageName }
};
var responseStorage = httpClient.GetAsync($@"{APIEndpoint.Core}{storageURI}?filter=" + JsonConvert.SerializeObject(filterStorage)).Result.Content.ReadAsStringAsync();
Dictionary <string, object> resultStorage = JsonConvert.DeserializeObject <Dictionary <string, object> >(responseStorage.Result);
var jsonStorage = resultStorage.Single(p => p.Key.Equals("data")).Value;
Dictionary <string, object> storage = JsonConvert.DeserializeObject <List <Dictionary <string, object> > >(jsonStorage.ToString())[0];
#endregion Storage
#region Inventory Document
List <InventoryDocumentItem> inventoryDocumentItems = new List <InventoryDocumentItem>();
foreach (FPReturnInvToPurchasingDetail detail in model.FPReturnInvToPurchasingDetails)
{
InventoryDocumentItem inventoryDocumentItem = new InventoryDocumentItem
{
ProductId = int.Parse(detail.ProductId),
ProductCode = detail.ProductCode,
ProductName = detail.ProductName,
Quantity = detail.Length,
UomId = int.Parse(uom["Id"].ToString()),
UomUnit = uom["Unit"].ToString()
};
inventoryDocumentItems.Add(inventoryDocumentItem);
}
InventoryDocument inventoryDocument = new InventoryDocument
{
Date = DateTimeOffset.UtcNow,
ReferenceNo = model.No,
ReferenceType = "Bon Retur Barang - Pembelian",
Type = Type,
StorageId = int.Parse(storage["_id"].ToString()),
StorageCode = storage["code"].ToString(),
StorageName = storage["name"].ToString(),
Items = inventoryDocumentItems
};
var inventoryDocumentFacade = ServiceProvider.GetService <IInventoryDocumentService>();
return(await inventoryDocumentFacade.Create(inventoryDocument));
#endregion Inventory Document
}
public async Task <int> CreateInventoryDocument(MaterialDistributionNote model, string type)
{
string storageURI = "master/storages";
string uomURI = "master/uoms";
IHttpServiceRepository httpClient = (IHttpServiceRepository)_serviceProvider.GetService(typeof(IHttpServiceRepository));
/* Get UOM */
Dictionary <string, object> filterUom = new Dictionary <string, object> {
{ "Unit", "MTR" }
};
var responseUom = httpClient.GetAsync($@"{APIEndpoint.Core}{uomURI}?filter=" + JsonConvert.SerializeObject(filterUom)).Result.Content.ReadAsStringAsync();
Dictionary <string, object> resultUom = JsonConvert.DeserializeObject <Dictionary <string, object> >(responseUom.Result);
var jsonUom = resultUom.Single(p => p.Key.Equals("data")).Value;
Dictionary <string, object> Uom = JsonConvert.DeserializeObject <List <Dictionary <string, object> > >(jsonUom.ToString())[0];
/* Get Storage */
var storageName = model.UnitName.Equals("PRINTING") ? "Warehouse Here Printing" : "Warehouse Here Finishing";
Dictionary <string, object> filterStorage = new Dictionary <string, object> {
{ "name", storageName }
};
var responseStorage = httpClient.GetAsync($@"{APIEndpoint.Core}{storageURI}?filter=" + JsonConvert.SerializeObject(filterStorage)).Result.Content.ReadAsStringAsync();
Dictionary <string, object> resultStorage = JsonConvert.DeserializeObject <Dictionary <string, object> >(responseStorage.Result);
var jsonStorage = resultStorage.Single(p => p.Key.Equals("data")).Value;
Dictionary <string, object> storage = JsonConvert.DeserializeObject <List <Dictionary <string, object> > >(jsonStorage.ToString())[0];
/* Create Inventory Document */
List <InventoryDocumentItem> inventoryDocumentItems = new List <InventoryDocumentItem>();
List <MaterialDistributionNoteDetail> mdnds = new List <MaterialDistributionNoteDetail>();
foreach (MaterialDistributionNoteItem mdni in model.MaterialDistributionNoteItems)
{
mdnds.AddRange(mdni.MaterialDistributionNoteDetails);
}
foreach (MaterialDistributionNoteDetail mdnd in mdnds)
{
InventoryDocumentItem inventoryDocumentItem = new InventoryDocumentItem
{
ProductId = int.Parse(mdnd.ProductId),
ProductCode = mdnd.ProductCode,
ProductName = mdnd.ProductName,
Quantity = mdnd.ReceivedLength,
StockPlanning = model.Type != "RE-GRADING" ? (mdnd.DistributedLength == 0 ? mdnd.MaterialRequestNoteItemLength - mdnd.ReceivedLength : mdnd.ReceivedLength * -1) : mdnd.ReceivedLength * -1,
UomId = int.Parse(Uom["Id"].ToString()),
UomUnit = Uom["Unit"].ToString()
};
inventoryDocumentItems.Add(inventoryDocumentItem);
}
List <InventoryDocumentItem> list = inventoryDocumentItems
.GroupBy(m => new { m.ProductId, m.ProductCode, m.ProductName })
.Select(s => new InventoryDocumentItem
{
ProductId = s.First().ProductId,
ProductCode = s.First().ProductCode,
ProductName = s.First().ProductName,
Quantity = s.Sum(d => d.Quantity),
StockPlanning = s.Sum(d => d.StockPlanning),
UomUnit = s.First().UomUnit,
UomId = s.First().UomId
}).ToList();
InventoryDocument inventoryDocument = new InventoryDocument
{
Date = DateTimeOffset.UtcNow,
ReferenceNo = model.No,
ReferenceType = "Bon introduction to Here",
Type = type,
StorageId = int.Parse(storage["Id"].ToString()),
StorageCode = storage["Code"].ToString(),
StorageName = storage["Name"].ToString(),
Items = list
};
var inventoryDocumentFacade = _serviceProvider.GetService <IInventoryDocumentRepository>();
return(await inventoryDocumentFacade.Create(inventoryDocument));
}
public async Task <int> Create(InventoryDocument model)
{
int created = 0;
var internalTransaction = _inventoryDbContext.Database.CurrentTransaction == null;
var transaction = !internalTransaction ? _inventoryDbContext.Database.CurrentTransaction : _inventoryDbContext.Database.BeginTransaction();
try
{
model.No = GenerateNo(model);
model.FlagForCreate(_identityInterface.Username, UserAgent);
model.FlagForUpdate(_identityInterface.Username, UserAgent);
foreach (var item in model.Items)
{
item.FlagForCreate(_identityInterface.Username, UserAgent);
item.FlagForUpdate(_identityInterface.Username, UserAgent);
}
_dbSet.Add(model);
created = await _inventoryDbContext.SaveChangesAsync();
foreach (var item in model.Items)
{
var qty = item.Quantity;
if (model.Type == "OUT")
{
qty = item.Quantity * -1;
}
var sumQty = _inventoryDbContext.InventoryMovements.Where(a => a.IsDeleted == false && a.StorageId == model.StorageId && a.ProductId == item.ProductId && a.UomId == item.UomId).Sum(a => a.Quantity);
InventoryMovement movementModel = new InventoryMovement
{
ProductCode = item.ProductCode,
ProductId = item.ProductId,
ProductName = item.ProductName,
StorageCode = model.StorageCode,
StorageId = model.StorageId,
StorageName = model.StorageName,
Before = sumQty,
Quantity = qty,
After = sumQty + qty,
ReferenceNo = model.ReferenceNo,
ReferenceType = model.ReferenceType,
Type = model.Type,
Date = model.Date,
UomId = item.UomId,
UomUnit = item.UomUnit,
Remark = item.ProductRemark
};
var movement = _serviceProvider.GetService <IInventoryMovementRepository>();
await movement.Create(movementModel);
}
if (internalTransaction)
{
transaction.Commit();
}
return(created);
}
catch (Exception e)
{
if (internalTransaction)
{
transaction.Rollback();
}
throw new Exception(e.Message);
}
}
