public async Task <List <ContractInfo> > GetFullContractOnOrganization(int organizationId)
{
List <ContractInfo> fullInfo = new List <ContractInfo>();
List <Contract> orgContracts;
using (var context = new ContractContext())
{
orgContracts = await context.Contracts.Where(con => con.OrganizationId == organizationId).AsNoTracking().ToListAsync();
}
foreach (var contract in orgContracts)
{
var hardwareTask = await HardwaresForContractAsync(contract);
var softwareTask = await SoftwaresForContractAsynk(contract);
fullInfo.Add(
new ContractInfo()
{
Id = contract.Id,
Number = contract.Number,
StartDate = contract.StartDate,
EndDate = contract.EndDate,
HardwareForInfo = hardwareTask,
SoftwareForInfo = softwareTask
}
);
}
return(fullInfo);
}
public async Task ChangeOrganization(OrganizationDTO organization)
{
using (ContractContext context = new ContractContext())
{
var org = context.Organizations.Where(org => org.Id == organization.Id).FirstOrDefault();
if (!org.Name.Equals(organization.Name))
{
org.Name = organization.Name;
}
if (!org.FullName.Equals(organization.FullName))
{
org.FullName = organization.FullName;
}
if (!org.Address.Equals(organization.Address))
{
org.Address = organization.Address;
}
if (!org.Email.Equals(organization.Email))
{
org.Email = organization.Email;
}
if (!org.Smdo.Equals(organization.Smdo))
{
org.Smdo = organization.Smdo;
}
await context.SaveChangesAsync();
}
}
public bool CheckCompatibility(ContractContext context)
{
if (null == context)
{
throw new ArgumentNullException(nameof(context));
}
return(true);
}
//[ClassInitialize]
public static void Init(TestContext context)
{
//Used for connectionstring
AppDomain.CurrentDomain.SetData("DataDirectory", System.IO.Directory.GetCurrentDirectory());
var db = new ContractContext("");
db.Contracts.RemoveRange(db.Contracts);
db.SaveChanges();
}
public async Task DelAreaAsync(int id)
{
using (ContractContext context = new ContractContext())
{
var area = await context.Areas.FindAsync(id);
context.Areas.Remove(area);
await context.SaveChangesAsync();
}
}
public async Task UpdateAreaAsync(AreaDTO areaDTO)
{
using (ContractContext context = new ContractContext())
{
var area = await context.Areas.Where(a => a.Id == areaDTO.Id).SingleAsync();
area.FullName = areaDTO.FullName;
area.SimpleName = areaDTO.SimpleName;
await context.SaveChangesAsync();
}
}
public async Task AddPerson(PersonDTO personDTO)
{
var config = new MapperConfiguration(cfg => cfg.CreateMap <PersonDTO, Person>());
var mapper = new Mapper(config);
using (ContractContext context = new ContractContext())
{
await context.People.AddAsync(mapper.Map <Person>(personDTO));
await context.SaveChangesAsync();
}
}
public async Task <List <ServiceInfoDTO> > GetServicesInfoAsync()
{
List <ServiceInfo> services = new List <ServiceInfo>();
var config = new MapperConfiguration(cfg => cfg.CreateMap <ServiceInfo, ServiceInfoDTO>());
var mapper = new Mapper(config);
using (ContractContext context = new ContractContext())
{
services = await context.ServiceInfo.AsNoTracking().ToListAsync();
}
return(mapper.Map <List <ServiceInfoDTO> >(services));
}
public Form GetForm(ContractContext context)
{
if (null == context)
{
throw new ArgumentNullException(nameof(context));
}
var signatures = context.Contract.Signatures.Select(s =>
{
var formattingService = context.UnityContainer.Resolve <IFormattingService>();
var identifierValue = formattingService.FormatIdentifier(s.AcceptorIdentifier);
var acceptTimeValue = null == s.AcceptTime
? string.Empty
: formattingService.FormatDateTime(s.AcceptTime.Value);
return(new ListItemContent(new ResultRecord(identifierValue, acceptTimeValue))
{
ImageKey = "Ant"
});
})
.ToList();
var valuesWrapper = new ContractDetailsFormValuesWrapper
{
Control1Name = context.Contract.Name,
Control2Text = context.Contract.Text,
Control3HasLimitedAccess = !context.Contract.IsPublic,
Control4Details = signatures
};
var form = SubmitFormDisplayHelper.LoadSubmitFormByExtensionId(context.ExtensionManager,
ExtensionCatalog.ContractDetails, valuesWrapper.CollectIncomeValues());
form.ServiceCommand += (sender, args) =>
{
if (!"Copy".Equals(args.Command))
{
return;
}
var resultRecord = args.Argument as ResultRecord;
if (null != resultRecord)
{
string text = string.Format(CultureInfo.InvariantCulture, "{0} {1}", resultRecord.Name,
resultRecord.Value);
Clipboard.SetText(text, TextDataFormat.UnicodeText);
}
};
return(form);
}
public async Task AddAreaAsync(AreaDTO areaDTO)
{
var config = new MapperConfiguration(cfg => cfg.CreateMap <AreaDTO, Area>());
var mapper = new Mapper(config);
var area = mapper.Map <Area>(areaDTO);
using (ContractContext context = new ContractContext())
{
await context.Areas.AddAsync(area);
await context.SaveChangesAsync();
}
}
public async Task <List <AreaToMenu> > GetAreasSimpleAsync()
{
List <AreaToMenu> areas = new List <AreaToMenu>();
using (ContractContext context = new ContractContext())
{
areas = await context.Areas.Select(a => new AreaToMenu()
{
Id = a.Id,
SimpleName = a.SimpleName
}).
OrderBy(a => a.SimpleName).AsNoTracking().ToListAsync();
}
return(areas);
}
private async Task <List <HardwareForInfo> > HardwaresForContractAsync(Contract contract)
{
List <HardwareForInfo> hardwares = new List <HardwareForInfo>();
using (var context = new ContractContext())
{
hardwares = await context.ServiceHardwares.Where(hard => hard.ContractId == contract.Id).Include(info => info.ServiceInfo).
Select(item => new HardwareForInfo()
{
ServerCount = item.ServerCount,
WorkplaceCount = item.WorkplaceCount,
ServiceInfoName = item.ServiceInfo.Name
}).AsNoTracking().ToListAsync();
}
return(hardwares);
}
private async Task <List <SoftwareForInfo> > SoftwaresForContractAsynk(Contract contract)
{
List <SoftwareForInfo> softwares = new List <SoftwareForInfo>();
using (var context = new ContractContext())
{
softwares = await context.ServiceSoftwares.Where(hard => hard.ContractId == contract.Id).Include(info => info.ServiceInfo).
Select(item => new SoftwareForInfo()
{
MainPlaceCount = item.MainPlaceCount,
AdditionalPlaceCount = item.AdditionalPlaceCount,
ServiceInfoName = item.ServiceInfo.Name
}).AsNoTracking().ToListAsync();
}
return(softwares);
}
public async Task <List <OrganizationDTO> > GetOrganizationOnAreaAsync(int areaId)
{
List <OrganizationDTO> organization = new List <OrganizationDTO>();
List <Organization> AllOrganizations = new List <Organization>();
using (ContractContext context = new ContractContext())
{
AllOrganizations = await context.Organizations.Where(org => org.AreaId == areaId).OrderBy(org => org.FullName).AsNoTracking().ToListAsync();
}
var config = new MapperConfiguration(cfg => cfg.CreateMap <Organization, OrganizationDTO>());
var mapper = new Mapper(config);
organization = mapper.Map <List <OrganizationDTO> >(AllOrganizations);
return(organization);
}
public async Task <List <PersonWithOrgName> > GetPersonWithOrg()
{
var personWithOrgName = new List <PersonWithOrgName>();
var config = new MapperConfiguration(cfg => cfg.CreateMap <Person, PersonDTO>());
var mapper = new Mapper(config);
using (ContractContext context = new ContractContext())
{
personWithOrgName = await context.People.OrderBy(p => p.LastName).AsNoTracking().Select(p => new PersonWithOrgName()
{
Person = mapper.Map <PersonDTO>(p),
OrgName = p.Organization.Name
}).ToListAsync();;
}
return(personWithOrgName);
}
public async Task <double> GetCostOnPeriod(int areaId, DateTime startFilter, DateTime endFilter)
{
double fullCost = 0;
List <Contract> contracts;
using (ContractContext context = new ContractContext())
{
// Where Is filter contract on crossing date. If contract started and ended before filter it skip
contracts = await context.Contracts.Where(c => c.Organization.AreaId == areaId).Include(c => c.ServicesHardware).ThenInclude(sh => sh.ServiceInfo).
Include(c => c.ServicesSoftware).ThenInclude(sh => sh.ServiceInfo).
Where((c => (!((startFilter < c.StartDate && endFilter < c.StartDate) || (startFilter > c.EndDate && endFilter > c.EndDate))))).
AsNoTracking().ToListAsync();
}
fullCost += GetCostHardware(contracts, startFilter, endFilter);
fullCost += GetCostSoftware(contracts, startFilter, endFilter);
return(fullCost);
}
public async Task <List <AreaCountOrg> > GetAreasForIndexAsync()
{
List <AreaCountOrg> areas = new List <AreaCountOrg>();
var config = new MapperConfiguration(cfg => cfg.CreateMap <Area, AreaDTO>());
var mapper = new Mapper(config);
using (ContractContext context = new ContractContext())
{
areas = await context.Areas.Include(a => a.Organizations).Select(area => new AreaCountOrg()
{
Area = mapper.Map <AreaDTO>(area),
CountOrg = area.Organizations.Count()
}).AsNoTracking().ToListAsync();
}
return(areas);
}
public async Task AddOrganization(OrganizationDTO organizationDTO, PersonDTO personDTO)
{
var configOrganization = new MapperConfiguration(cfg => cfg.CreateMap <OrganizationDTO, Organization>());
var configPerson = new MapperConfiguration(cfg => cfg.CreateMap <PersonDTO, Person>());
var mapperOrganization = new Mapper(configOrganization);
var mapperPerson = new Mapper(configPerson);
var organization = mapperOrganization.Map <Organization>(organizationDTO);
var person = mapperPerson.Map <Person>(personDTO);
person.Organization = organization;
using (ContractContext context = new ContractContext())
{
await context.People.AddAsync(person);
await context.SaveChangesAsync();
}
}
public void RunAction(ContractContext context)
{
if (null == context)
{
throw new ArgumentNullException(nameof(context));
}
_synchronizationContex = SynchronizationContext.Current;
ThreadPool.QueueUserWorkItem(state =>
{
Exception exception = null;
try
{
var contractService = context.UnityContainer.Resolve <IContractService>();
contractService.RefreshContract(context.Contract.Id);
}
catch (Exception e)
{
exception = e;
}
_synchronizationContex.Post(o =>
{
if (null != exception)
{
var errorContext =
new ErrorContext(exception.GetType().Name, exception.Message)
{
Details = exception.ToString()
};
context.ExtensionManager.GetErrorFormProvider().GetForm(errorContext).Show();
}
EventBroker.OnContractChanged();
}, null);
});
}
public async Task UpdatePerson(PersonDTO personDTO)
{
var config = new MapperConfiguration(cfg => cfg.CreateMap <PersonDTO, Person>());
var mapper = new Mapper(config);
using (ContractContext context = new ContractContext())
{
var person = await context.People.Where(p => p.Id == personDTO.Id).FirstOrDefaultAsync();;
if (!person.FirstName.Equals(personDTO.FirstName))
{
person.FirstName = personDTO.FirstName;
}
if (!person.LastName.Equals(personDTO.LastName))
{
person.LastName = personDTO.LastName;
}
if (!person.MiddleName.Equals(personDTO.MiddleName))
{
person.MiddleName = personDTO.MiddleName;
}
if (!person.Position.Equals(personDTO.Position))
{
person.Position = personDTO.Position;
}
if (!person.Phone.Equals(personDTO.Phone))
{
person.Phone = personDTO.Phone;
}
if (!person.Email.Equals(personDTO.Email))
{
person.Email = personDTO.Email;
}
if (!person.MobilePhone?.Equals(personDTO.MobilePhone) ?? true)
{
person.MobilePhone = personDTO.MobilePhone;
}
await context.SaveChangesAsync();
}
}
public bool CheckCompatibility(ContractContext context)
{
if (null == context)
{
throw new ArgumentNullException(nameof(context));
}
if (context.Contract.IsPublic)
{
return(true);
}
switch (context.Contract.State)
{
case ContractState.Created:
case ContractState.Signed:
return(true);
default:
return(false);
}
}
public async Task AddContract(ContractDTO contractDTO, List <ServiceHardwareDTO> hardwaresDTO, List <ServiceSoftwareDTO> softwaresDTO)
{
var configContract = new MapperConfiguration(cfg => cfg.CreateMap <ContractDTO, Contract>());
var configHardwares = new MapperConfiguration(cfg => cfg.CreateMap <ServiceHardwareDTO, ServiceHardware>());
var configSoftwares = new MapperConfiguration(cfg => cfg.CreateMap <ServiceSoftwareDTO, ServiceSoftware>());
var mapperContract = new Mapper(configContract);
var mapperHardwares = new Mapper(configHardwares);
var mapperSoftwares = new Mapper(configSoftwares);
Contract contract = mapperContract.Map <Contract>(contractDTO);
List <ServiceHardware> hardwares = mapperHardwares.Map <List <ServiceHardware> >(hardwaresDTO);
List <ServiceSoftware> softwares = mapperSoftwares.Map <List <ServiceSoftware> >(softwaresDTO);
contract.ServicesHardware = hardwares;
contract.ServicesSoftware = softwares;
using (ContractContext context = new ContractContext())
{
await context.Contracts.AddAsync(contract);
await context.SaveChangesAsync();
}
}
public Form GetForm(ContractContext context)
{
_context = context ?? throw new ArgumentNullException(nameof(context));
return(GetForm(context.Contract));
}
public ContractRepository(ContractContext context)
{
_context = context;
}
public LoginManager(ContractContext context)
{
_contractContext = context;
}
static void Main(string[] args)
{
var contractFiles = Directory.GetFiles(@"C:\Users\SSV\Documents\Visual Studio 2017\Projects\XmlToSqlProject\ShortContract\contracts");
var contractProvider = new ContractXmlProvider();
List <ContractXmlModel> contractXmlList = new List <ContractXmlModel>();
foreach (var item in contractFiles)
{
var contract = contractProvider.GetContract(item);
contractXmlList.Add(contract);
}
var contracts = CustomersConverter.ConvertContracts(contractXmlList);
var suppliers = contractXmlList.Select(m => CustomersConverter.ConvertSupplier(m.Supplier));
var customers = contractXmlList.Select(m => CustomersConverter.ConvertCustomer(m.Customer));
var uniqSuppliers = suppliers.Distinct(new SupplierComparer()).ToList();
var uniqCustomers = customers.Distinct(new CustomerComparer()).ToList();
foreach (var item in contracts)
{
var sup = uniqSuppliers.FirstOrDefault(s => s.Inn.Equals(item.Supplier.Inn));
item.Supplier = sup;
var cus = uniqCustomers.FirstOrDefault(s => s.Inn.Equals(item.Customer.Inn));
item.Customer = cus;
}
//foreach (var sup in uniqSuppliers)
//{
// var contr = contracts.Where(c => c.SupplierId.Equals(sup.Id));
// foreach (var item in contr)
// {
// sup.Contracts.Add(item);
// }
//}
//foreach (var cust in uniqCustomers)
//{
// var contr = contracts.Where(c => c.CustomerId.Equals(cust.Inn));
// foreach (var item in contr)
// {
// cust.Contracts.Add(item);
// }
//}
using (ContractContext context = new ContractContext())
{
//context.Contracts.RemoveRange(context.Contracts);
// context.Suppliers.RemoveRange(context.Suppliers);
// context.SaveChanges();
//context.Suppliers.AddRange(uniqSuppliers);
context.Contracts.AddRange(contracts);
//
context.SaveChanges();
}
Console.ReadLine();
}
public BeContractDalTest()
{
BeContractEquals = new BeContractEqualsTest();
Db = new ContractContext("");
}
public ContractHandler(ContractContext db) => this.db = db;
public Form GetForm(SessionContext context)
{
if (null == context)
{
throw new ArgumentNullException(nameof(context));
}
var origin = new FilterOrigin(context.ExtensionManager,
ExtensionCatalog.ContractFilter)
{
MenuItemsTagName = ExtensionCatalog.Tags.ContractExtension,
CommandBarTagName = ExtensionCatalog.Tags.ContractFilterExtension,
ColumnsSettings = context.Session.SettingsService.GetSettings().ContractSettings
};
var template = FilterDisplayHelper.LoadFilterFormTemplate(origin);
template.Title = Translator.Instance.Translate(ExtensionCatalog.TransferFilter, "Contracts");
// Отключаем кнопки.
foreach (var buttonTemplate in template.FilterScreen.CommandButtons)
{
var formProvider =
context.ExtensionManager.TryGetTopFormProvider(buttonTemplate.Command);
if (!(formProvider?.CheckCompatibility(context) ?? false))
{
buttonTemplate.Enabled = false;
}
}
_form = new FilterForm();
ErrorFormDisplayHelper.ApplyErrorAction(context.ExtensionManager, _form);
var now = DateTime.Now;
var incomeValuesWrapper = new TransferFilterFormValuesWrapper
{
Control1FromTime = new DateTime(now.Year, now.Month, now.Day, 0, 0, 0, DateTimeKind.Local),
Control2ToTime = new DateTime(now.Year, now.Month, now.Day, 23, 59, 59, DateTimeKind.Local)
};
_form.ApplyTemplate(template);
_form.ApplyShapeValues(incomeValuesWrapper.CollectIncomeValues());
// Подписка на создание/изменение контракта
EventBroker.ContractChanged += EventBrokerOnContractChanged;
// Сохранение документа
_form.SaveItemsCallback = (s, list) =>
{
var importExportService = context.UnityContainer.Resolve <IImportExportService>();
importExportService.Save(list, s);
};
// Сохранение настроек
_form.FormClosing += (sender, args) =>
{
var settings = context.Session.SettingsService.GetSettings();
var contractSettings = settings.ContractSettings;
FilterDisplayHelper.UpdateColumnsSettings(contractSettings, _form.SelectGridSettings());
context.Session.SettingsService.SetSettings(settings);
context.Session.SettingsService.Save();
};
// Меню
_form.MenuItemResolver = (entity, command) =>
{
var contract = _form.CurrentEntity as IContract;
if (null == contract)
{
return(false);
}
var contractContext = new ContractContext(context, contract);
if (command.Equals(ExtensionCatalog.RefreshContract))
{
var actionProvider = context.ExtensionManager.TryGetContractActionProvider(command);
return(actionProvider?.CheckCompatibility(contractContext) ?? false);
}
var formProvider = context.ExtensionManager.TryGetContractFormProvider(command);
return(formProvider?.CheckCompatibility(contractContext) ?? false);
};
// Обработка событий.
_form.ServiceCommand += (sender, args) =>
{
string command = args.Command;
if (null == command)
{
throw new InvalidOperationException("null == command");
}
if (command.StartsWith("CellContentClick:", StringComparison.Ordinal))
{
return;
}
if (command.StartsWith("CellMouseDoubleClick:", StringComparison.Ordinal))
{
command = ExtensionCatalog.ContractDetails;
}
var contract = args.Argument as IContract;
// Кнопки
if (null == contract)
{
var formProvider = context.ExtensionManager.TryGetTopFormProvider(command);
formProvider?.GetForm(context).Show(_form);
}
else
{
var contractContext = new ContractContext(context, contract);
if (command.Equals(ExtensionCatalog.RefreshContract))
{
var actionProvider = context.ExtensionManager.TryGetContractActionProvider(command);
actionProvider?.RunAction(contractContext);
}
else
{
var formProvider = context.ExtensionManager.TryGetContractFormProvider(command);
formProvider?.GetForm(contractContext).Show(_form);
}
}
};
// Команда Refresh
_form.WorkCallback = values =>
{
var valuesWrapper = new ContractFilterFormValuesWrapper(values);
var contractService = context.UnityContainer.Resolve <IContractService>();
var contracts =
contractService.SelectContracts(valuesWrapper.Control1FromTime, valuesWrapper.Control2ToTime);
var gridRowContentList = new List <GridRowContent>();
int signed = 0;
int unsigned = 0;
var contractSettings = context.Session.SettingsService.GetSettings().ContractSettings;
foreach (var contract in contracts)
{
var gridRowContent = new GridRowContent(contract.Id.ToString(), contract);
switch (contract.State)
{
case ContractState.Created:
gridRowContent.BackColor = Color.White;
gridRowContent.SelectionBackColor = contractSettings.SelectionColor;
unsigned++;
break;
case ContractState.Signed:
case ContractState.Completed:
gridRowContent.BackColor = contractSettings.SignedColor;
gridRowContent.SelectionBackColor =
ColorUtility.CalculateSelectionColor(contractSettings.SignedColor);
signed++;
break;
default:
throw new InvalidOperationException("contract.State == " + contract.State);
}
if (0 == contract.AccessCount)
{
gridRowContent.ForeColor = contractSettings.PublicForeColor;
gridRowContent.SelectionForeColor = contractSettings.PublicForeColor;
}
gridRowContentList.Add(gridRowContent);
}
var filterScreenContent = new FilterScreenContent();
filterScreenContent.RowContentList.AddRange(gridRowContentList);
var filterFormContent = new FilterFormContent(filterScreenContent);
filterFormContent.LabelValues.Add(string.Format(CultureInfo.InvariantCulture, "SIG: {0}", signed));
filterFormContent.LabelValues.Add(string.Format(CultureInfo.InvariantCulture, "UNSIG: {0}", unsigned));
return(filterFormContent);
};
_form.Disposed += (sender, args) =>
{
EventBroker.ContractChanged -= EventBrokerOnContractChanged;
};
return(_form);
}
static async Task SeedContractContext(ContractContext context, IServiceProvider services)
{
context.EnsureEnumeration <BillingMode>();
await context.SaveChangesAsync();
}
