protected override void RemoveAbstract(TeamDeleteModel entity)
{
var output = new LogicResult <TeamViewModel>();
var data = Uow.GetRepository <Team>().GetById(entity.Id);
if (data != null)
{
while (data.Users.Count() > 0)
{
data.Users.FirstOrDefault().TeamId = null;
Uow.GetRepository <User>().Update(data.Users.FirstOrDefault());
}
Uow.GetRepository <Team>().Remove(data);
}
else
{
output.ErrorList.Add(new Error
{
Code = "400",
Text = "id is incorrect",
Type = Utils.Enums.OperationResultCode.Information
});
}
Result = output;
}
public void Execute(DicColorTZRequestRelation colorTz)
{
var repo = Uow.GetRepository <DicColorTZRequestRelation>();
repo.Create(colorTz);
Uow.SaveChanges();
}
public void Execute(Payment payment)
{
var paymentRepository = Uow.GetRepository <Payment>();
paymentRepository.Update(payment);
Uow.SaveChanges();
}
public async Task ExecuteAsync(List <RequestEarlyReg> earlyRegs)
{
var earlyRegRepo = Uow.GetRepository <RequestEarlyReg>();
earlyRegRepo.DeleteRange(earlyRegs);
await Uow.SaveChangesAsync();
}
public void Execute(ApplicationRole role)
{
var repository = Uow.GetRepository <ApplicationRole>();
repository.Update(role);
Uow.SaveChanges();
}
public async Task <HttpResponseMessage> Delete(int userId, int personId)
{
await Uow.GetRepository <IUserAccountRepository>().DeleteAsync(userId, personId);
Uow.Commit();
return(new HttpResponseMessage(HttpStatusCode.NoContent));
}
public Domain.Entities.Dictionaries.DicDepartment Execute(string code)
{
var repo = Uow.GetRepository <Domain.Entities.Dictionaries.DicDepartment>();
var department = repo.AsQueryable().FirstOrDefault(d => d.Code.Equals(code));
return(department);
}
public void ExecuteAsync(ContractWorkflow contractWorkflow)
{
var contractWorkflowRepository = Uow.GetRepository <ContractWorkflow>();
contractWorkflowRepository.Update(contractWorkflow);
Uow.SaveChanges();
}
public async Task <ProtectionDocParallelWorkflow> ExecuteAsync(int protectionDocWorkflowId)
{
var requestParallelWorkflowRepository = Uow.GetRepository <ProtectionDocParallelWorkflow>();
var parallelWorkflows = requestParallelWorkflowRepository.AsQueryable();
return(await parallelWorkflows.FirstOrDefaultAsync(x => x.ProtectionDocWorkflowId == protectionDocWorkflowId && !x.IsFinished));
}
public void Uow_GetList_WhereHitsLessThan7SelectPosts()
{
var result = Uow.GetRepository <Blog>().GetList(predicate: x => x.Hits < 7, selector: y => y.Posts);
Assert.That(result.Count, Is.GreaterThan(0));
Assert.That(result.FirstOrDefault().FirstOrDefault(), Is.TypeOf <Post>());
}
public void Execute(ICISRequest icisRequest)
{
var repo = Uow.GetRepository <ICISRequest>();
repo.Update(icisRequest);
Uow.SaveChanges();
}
public void Execute(int protectionDocId, List <ProtectionDocCustomer> customers)
{
var protectionDocRepository = Uow.GetRepository <ProtectionDoc>();
var protectionDoc = protectionDocRepository.AsQueryable()
.Include(pd => pd.Type)
.FirstOrDefault(pd => pd.Id == protectionDocId);
if (protectionDoc == null)
{
throw new DataNotFoundException(nameof(ProtectionDoc), DataNotFoundException.OperationType.Read, protectionDocId);
}
string roleCode;
if (protectionDoc.Type.Code == DicProtectionDocTypeCodes.RequestTypeTrademarkCode ||
protectionDoc.Type.Code == DicProtectionDocTypeCodes.RequestTypeNameOfOriginCode ||
protectionDoc.Type.Code == DicProtectionDocTypeCodes.ProtectionDocTypeTrademarkCode ||
protectionDoc.Type.Code == DicProtectionDocTypeCodes.ProtectionDocTypeNameOfOriginCode)
{
roleCode = DicCustomerRoleCodes.Owner;
}
else
{
roleCode = DicCustomerRoleCodes.PatentOwner;
}
var roleRepository = Uow.GetRepository <DicCustomerRole>();
var owner = roleRepository.AsQueryable().FirstOrDefault(r => r.Code == roleCode);
if (owner == null)
{
throw new DataNotFoundException(nameof(DicCustomerRole), DataNotFoundException.OperationType.Read, roleCode);
}
var protectionDocCustomerRepository = Uow.GetRepository <ProtectionDocCustomer>();
foreach (var customer in customers)
{
var customerRole = roleRepository.GetById(customer.CustomerRoleId);
customer.ProtectionDocId = protectionDocId;
if (customerRole.Code == DicCustomerRoleCodes.Declarant)
{
var patentOwner = new ProtectionDocCustomer
{
CustomerId = customer.CustomerId,
ProtectionDocId = protectionDocId,
Address = customer.Address,
CustomerRoleId = owner.Id,
Phone = customer.Phone,
PhoneFax = customer.PhoneFax,
MobilePhone = customer.MobilePhone,
Email = customer.Email
};
protectionDocCustomerRepository.Create(patentOwner);
}
}
protectionDocCustomerRepository.CreateRange(customers);
Uow.SaveChanges();
}
public async Task <BibliographicDataDto> ExecuteAsync(int protectionDocId)
{
var requestRepository = Uow.GetRepository <ProtectionDoc>();
var protectionDoc = await requestRepository
.AsQueryable()
.Include(r => r.ProtectionDocInfo).ThenInclude(i => i.BreedCountry)
.Include(r => r.CurrentWorkflow).ThenInclude(cw => cw.CurrentStage)
.Include(r => r.CurrentWorkflow).ThenInclude(cw => cw.FromStage)
.Include(r => r.Type)
.Include(r => r.ProtectionDocCustomers).ThenInclude(c => c.CustomerRole)
.Include(r => r.ProtectionDocCustomers).ThenInclude(c => c.Customer).ThenInclude(c => c.Type)
.Include(r => r.ProtectionDocCustomers).ThenInclude(c => c.Customer).ThenInclude(c => c.Country)
.Include(r => r.IcgsProtectionDocs).ThenInclude(i => i.Icgs)
.Include(r => r.IcisProtectionDocs)
.Include(r => r.IpcProtectionDocs)
.Include(r => r.ColorTzs)
.Include(r => r.PaymentInvoices).ThenInclude(pi => pi.Tariff)
.Include(r => r.PaymentInvoices).ThenInclude(pi => pi.PaymentUses)
.Include(r => r.PaymentInvoices).ThenInclude(pi => pi.Status)
.Include(r => r.EarlyRegs).ThenInclude(c => c.RegCountry)
.Include(r => r.Icfems)
.Include(r => r.SubType)
.Include(r => r.ProtectionDocConventionInfos)
.Include(r => r.Workflows).ThenInclude(w => w.CurrentStage)
.Include(r => r.Workflows).ThenInclude(w => w.CurrentUser)
.Include(r => r.Documents).ThenInclude(rd => rd.Document).ThenInclude(d => d.Type)
.Include(r => r.SelectionAchieveType)
.Include(pd => pd.Bulletins).ThenInclude(pb => pb.Bulletin)
.FirstOrDefaultAsync(doc => doc.Id == protectionDocId);
return(_mapper.Map <ProtectionDoc, BibliographicDataDto>(protectionDoc));
}
public async Task <Request> ExecuteAsync(int protectionDocTypeId, string requestNum)
{
var repository = Uow.GetRepository <Request>();
var result = repository.AsQueryable()
.Include(r => r.RequestInfo).ThenInclude(i => i.BreedCountry)
.Include(r => r.CurrentWorkflow).ThenInclude(cw => cw.CurrentStage)
.Include(r => r.CurrentWorkflow).ThenInclude(cw => cw.FromStage)
.Include(r => r.ProtectionDocType)
.Include(r => r.RequestCustomers).ThenInclude(c => c.CustomerRole)
.Include(r => r.RequestCustomers).ThenInclude(c => c.Customer).ThenInclude(c => c.Type)
.Include(r => r.RequestCustomers).ThenInclude(c => c.Customer).ThenInclude(c => c.Country)
.Include(r => r.Addressee)
.Include(r => r.ICGSRequests).ThenInclude(i => i.Icgs)
.Include(r => r.ICISRequests)
.Include(r => r.IPCRequests)
.Include(r => r.ColorTzs)
.Include(r => r.PaymentInvoices).ThenInclude(pi => pi.Tariff)
.Include(r => r.PaymentInvoices).ThenInclude(pi => pi.PaymentUses)
.Include(r => r.PaymentInvoices).ThenInclude(pi => pi.Status)
.Include(r => r.EarlyRegs).ThenInclude(c => c.RegCountry)
.Include(r => r.Icfems)
.Include(r => r.RequestType)
.Include(r => r.RequestConventionInfos)
.Include(r => r.Department)
.FirstOrDefaultAsync(r =>
r.ProtectionDocTypeId.Equals(protectionDocTypeId) && r.RequestNum.Equals(requestNum));
return(await result);
}
public DicCustomer Execute(int customerId)
{
var customerRepository = Uow.GetRepository <DicCustomer>();
var customer = customerRepository.GetById(customerId);
return(customer);
}
public DicCustomerRole Execute(string code)
{
var repo = Uow.GetRepository <DicCustomerRole>();
return(repo.AsQueryable()
.FirstOrDefault(r => r.Code == code));
}
public void Execute(ApplicationUser user)
{
var repo = Uow.GetRepository <ApplicationUser>();
repo.Update(user);
Uow.SaveChanges();
}
public DicPaymentStatus Execute(string code)
{
var repo = Uow.GetRepository <DicPaymentStatus>();
return(repo.AsQueryable()
.FirstOrDefault(r => r.Code == code));
}
public DicTariff Execute(string code)
{
var repo = Uow.GetRepository <DicTariff>();
return(repo.AsQueryable()
.FirstOrDefault(d => d.Code == code));
}
public async Task ExecuteAsync(ProtectionDocCustomer protectionDocCustomer)
{
var repo = Uow.GetRepository <ProtectionDocCustomer>();
repo.Update(protectionDocCustomer);
await Uow.SaveChangesAsync();
}
public void Execute(List <DicTariff> dicTariffs)
{
var dicDouteStageRepository = Uow.GetRepository <DicTariff>();
dicDouteStageRepository?.CreateRangeAsync(dicTariffs);
Uow.SaveChangesAsync();
}
public Domain.Entities.Dictionaries.DicEventType Execute(string code)
{
var repo = Uow.GetRepository <Domain.Entities.Dictionaries.DicEventType>();
var type = repo.AsQueryable().FirstOrDefault(t => t.Code == code);
return(type);
}
public void Execute(PaymentUse paymentUse)
{
var paymentUseRepository = Uow.GetRepository <PaymentUse>();
paymentUseRepository.Update(paymentUse);
Uow.SaveChanges();
}
public async Task <RequestWorkflow> ExecuteAsync(Request request, int userId)
{
var dicProtectionDocTypesRepository = Uow.GetRepository <DicProtectionDocType>();
var protectionDocType = await dicProtectionDocTypesRepository.AsQueryable().FirstOrDefaultAsync(t => t.Id == request.ProtectionDocTypeId);
var dicRouteStagesRepository = Uow.GetRepository <DicRouteStage>();
var initialStage = await dicRouteStagesRepository.AsQueryable().FirstOrDefaultAsync(s => !s.IsDeleted && s.IsFirst && s.RouteId == protectionDocType.RouteId);
if (initialStage == null)
{
return(null);
}
var requestWorkflow = new RequestWorkflow
{
CurrentUserId = userId,
OwnerId = request.Id,
CurrentStageId = initialStage.Id,
RouteId = initialStage.RouteId,
IsComplete = initialStage.IsLast,
IsSystem = initialStage.IsSystem,
IsMain = initialStage.IsMain,
};
return(requestWorkflow);
}
public void UpdateCache <TDbEntity>(List <TDbEntity> entities)
{
try
{
CacheEntity type = CacheEntityMap.GetEntityTypeForDBEntity <TDbEntity>();
CacheStatus cacheStatus = Uow.CacheStatusesRepository.GetCacheStatus(type);
cacheStatus.Status = CacheEntryStatus.UpdateInProgress;
cacheStatus.LastUpdated = DateTime.UtcNow;
// try to get DB lock;
if (Uow.CacheStatusesRepository.TryUpdate(cacheStatus))
{
ICachedEntitiesRepository <TDbEntity> entityRepository = Uow.GetRepository <ICachedEntitiesRepository <TDbEntity> >();
Task task = entityRepository.UpdateCacheAsync(entities);
task.ContinueWith(task1 =>
{
using (IOptionsPlayUow uow = ObjectFactory.GetInstance <IOptionsPlayUow>())
{
cacheStatus = uow.CacheStatusesRepository.GetCacheStatus(type);
cacheStatus.Status = CacheEntryStatus.Active;
cacheStatus.LastUpdated = DateTime.UtcNow;
uow.CacheStatusesRepository.Update(cacheStatus);
uow.Commit();
}
});
}
}
catch (Exception ex)
{
Logging.Logger.Debug("thread ID:" + System.Threading.Thread.CurrentThread.ManagedThreadId.ToString() + ", UpdateCache Exception is:" + ex.StackTrace.ToString() + ", class is DatabaseCacheService");
}
}
public async Task ExecuteAsync(List <ICGSRequest> icgsRequests)
{
var icgsRequestRepo = Uow.GetRepository <ICGSRequest>();
icgsRequestRepo.DeleteRange(icgsRequests);
await Uow.SaveChangesAsync();
}
public bool Execute(Guid userId)
{
var userRepository = Uow.GetRepository <User>();
var user = userRepository.GetById(userId);
return(user != null && user.IsActive);
}
public Contract Execute(int requestId)
{
var repository = Uow.GetRepository <Contract>();
return(repository.AsQueryable()
.Include(r => r.CurrentWorkflow).ThenInclude(r => r.CurrentStage)
.Include(r => r.CurrentWorkflow).ThenInclude(r => r.Route)
.Select(d => new Contract
{
CurrentWorkflow = new ContractWorkflow
{
Route = d.CurrentWorkflow.Route,
CurrentStage = d.CurrentWorkflow.CurrentStage,
DateCreate = d.CurrentWorkflow.DateCreate,
Id = d.CurrentWorkflow.Id,
ExternalId = d.CurrentWorkflow.ExternalId,
DateUpdate = d.CurrentWorkflow.DateUpdate,
ControlDate = d.CurrentWorkflow.ControlDate,
CurrentStageId = d.CurrentWorkflow.CurrentStageId,
CurrentUserId = d.CurrentWorkflow.CurrentUserId,
DateReceived = d.CurrentWorkflow.DateReceived,
Description = d.CurrentWorkflow.Description,
FromStageId = d.CurrentWorkflow.FromStageId,
FromUserId = d.CurrentWorkflow.FromUserId,
OwnerId = d.CurrentWorkflow.OwnerId,
PreviousWorkflowId = d.CurrentWorkflow.PreviousWorkflowId,
RouteId = d.CurrentWorkflow.RouteId,
IsComplete = d.CurrentWorkflow.IsComplete,
IsMain = d.CurrentWorkflow.IsMain,
IsSystem = d.CurrentWorkflow.IsSystem
},
Id = d.Id
})
.FirstOrDefault(r => r.Id == requestId));
}
public async Task ExecuteAsync(List <RequestConventionInfo> requestConventionInfos)
{
var requestConventionInfoRepo = Uow.GetRepository <RequestConventionInfo>();
requestConventionInfoRepo.DeleteRange(requestConventionInfos);
await Uow.SaveChangesAsync();
}
public void Execute(PaymentInvoice paymentInvoice)
{
var paymentInvoiceRepository = Uow.GetRepository <PaymentInvoice>();
paymentInvoiceRepository.Delete(paymentInvoice);
Uow.SaveChanges();
}