/// <summary>
/// 判断是否存在供应商
/// </summary>
/// <param name="providerId">供应商主键</param>
/// <returns></returns>
public async Task <bool> ExistsProvider(Guid providerId)
{
using (IDAL.Master.IProviderDao providerDao = new ProviderDao())
{
return(await providerDao.GetAllAsync().AnyAsync(m => m.Id == providerId));
}
}
public async Task <List <Provider> > SearchProvider(string text)
{
using (var providerDao = new ProviderDao())
{
return(await providerDao.GetAllAsync().Where(m => m.Name.Contains(text)).ToListAsync());
}
}
public async Task <int> GetDataCount()
{
using (var providerDao = new ProviderDao())
{
return(await providerDao.GetAllAsync().CountAsync());
}
}
public void RunJob(DistributedTask _, CancellationToken cancellationToken)
{
try
{
CancellationToken = cancellationToken;
CoreContext.TenantManager.SetCurrentTenant(CurrentTenant);
Thread.CurrentPrincipal = principal;
Thread.CurrentThread.CurrentCulture = CultureInfo.GetCultureInfo(culture);
Thread.CurrentThread.CurrentUICulture = CultureInfo.GetCultureInfo(culture);
FolderDao = Global.DaoFactory.GetFolderDao();
FileDao = Global.DaoFactory.GetFileDao();
TagDao = Global.DaoFactory.GetTagDao();
ProviderDao = Global.DaoFactory.GetProviderDao();
FilesSecurity = new FileSecurity(Global.DaoFactory);
LinkDao = Global.GetLinkDao();
Logger = Global.Logger;
Total = InitTotalProgressSteps();
Do();
}
catch (AuthorizingException authError)
{
Error = FilesCommonResource.ErrorMassage_SecurityException;
Logger.Error(Error, new SecurityException(Error, authError));
}
catch (AggregateException ae)
{
ae.Flatten().Handle(e => e is TaskCanceledException || e is OperationCanceledException);
}
catch (Exception error)
{
Error = error is TaskCanceledException || error is OperationCanceledException
? FilesCommonResource.ErrorMassage_OperationCanceledException
: error.Message;
Logger.Error(error, error);
}
finally
{
try
{
TaskInfo.SetProperty(FINISHED, true);
PublishTaskInfo();
FolderDao.Dispose();
FileDao.Dispose();
TagDao.Dispose();
LinkDao.Dispose();
if (ProviderDao != null)
{
ProviderDao.Dispose();
}
}
catch { /* ignore */ }
}
}
public ActionResult Delete(string ma)
{
bool status = false;
status = new ProviderDao().Delete(ma);
return(Json(new { status = status }, JsonRequestBehavior.AllowGet));
}
public async Task RemoveProvider(Guid id)
{
using (var providerDao = new ProviderDao())
{
await providerDao.RemoveAsync(id);
}
}
public static List <string> GetProviderNameList()
{
if (providerList == null || providerList.Count == 0)
{
providerList = ProviderDao.Where(n => n.IsDeleted == false).ToList();
}
return(providerList.Select(n => n.Name).ToList());
}
public static List <ProviderDto> GetAllNotDeletedProviders()
{
if (allNotDeletedProviders == null || allNotDeletedProviders.Count == 0)
{
allNotDeletedProviders = ProviderDao.Where(n => n.IsDeleted == false).ToList();
}
return(allNotDeletedProviders);
}
public static List <ProviderDto> GetProviderList()
{
if (providerList == null || providerList.Count == 0)
{
providerList = ProviderDao.Where(n => n.IsDeleted == false).ToList();
}
return(providerList);
}
public AccountService(ILogger <AccountService> logger, AccountDao accountDao,
ProviderDao providerDao, AccountTypeDao accountTypeDao)
{
_accountDao = accountDao;
_providerDao = providerDao;
_accountTypeDao = accountTypeDao;
_logger = logger;
}
public static int Insert(ProviderDto dto)
{
int id = ProviderDao.Insert(dto);
dto.ProviderId = id;
allNotDeletedProviders.Add(dto);
allNotDeletedProviders = allNotDeletedProviders.OrderByDescending(n => n.ProviderId).ToList();
return(id);
}
public void Inserir(ProviderModelView providerModelView)
{
var provider = new Provider();
provider = PreparaProvider(providerModelView, provider);
var providerDao = new ProviderDao();
providerDao.Inserir(provider);
}
public void Atualizar(int id, ProviderModelView providerModelView)
{
var providerDao = new ProviderDao();
var provider = providerDao.ObeterPorId(id);
var providerAt = AtualizarProvider(providerModelView, provider);
providerAt.IdProvider = id;
providerDao.Atualizar(providerAt);
}
public async Task EditProvider(Guid providerId, string name)
{
using (var providerDao = new ProviderDao())
{
var provider = await providerDao.GetOneByIdAsync(providerId);
provider.Name = name;
await providerDao.EditAsync(provider);
}
}
public async Task CreateProvider(string name)
{
using (var providerDao = new ProviderDao())
{
await providerDao.CreateAsync(new Provider()
{
Name = name
});
}
}
public Provider PreparaProvider(ProviderModelView providerModelView, Provider provider)
{
var provider1 = new Provider();
ProviderDao providerDao = new ProviderDao();
var providerExistente = providerDao.ObterPorCnpj(providerModelView.Cnpj);
if (providerExistente != null)
{
throw new Exception("FORNECEDOR já existe.");
}
var cnpj = new ValidarCNPJ();
if (providerModelView.Cnpj.Trim().Length == 0)
{
throw new Exception("Informe o CNPJ.");
}
else if (providerModelView.Nome.Trim().Length == 0)
{
throw new Exception("Informe o NOME.");
}
else if (providerModelView.Cidade.Trim().Length == 0)
{
throw new Exception("Informe a CIDADE.");
}
else if (providerModelView.Responsavel.Trim().Length == 0)
{
throw new Exception("Informe o RESPONSAVEL.");
}
else if (providerModelView.Telefone.Trim().Length == 0)
{
throw new Exception("Informe o TELEFONE.");
}
else if (providerModelView.Email.Trim().Length == 0)
{
throw new Exception("Informe o EMAIL.");
}
else if (cnpj.IsCnpj(providerModelView.Cnpj) == false)
{
throw new Exception("CNPJ INVÁLIDO.");
}
else
{
provider1.Cnpj = providerModelView.Cnpj;
provider1.Nome = providerModelView.Nome;
provider1.Cidade = providerModelView.Cidade;
provider1.Responsavel = providerModelView.Responsavel;
provider1.Telefone = providerModelView.Telefone;
provider1.Email = providerModelView.Email;
}
return(provider1);
}
/// <summary>
/// 供应商查询
/// </summary>
/// <param name="pageSize"></param>
/// <param name="pageIndex"></param>
/// <param name="asc"></param>
/// <returns></returns>
public async Task <List <DTO.Master.ProviderDto> > GetAllProvider(int pageIndex = 1, int pageSize = 10, bool asc = true)
{
using (var providerDao = new ProviderDao())
{
return(await providerDao.GetAllByPageOrderAsync(pageIndex - 1, pageSize, asc).Select(m => new DTO.Master.ProviderDto()
{
Id = m.Id,
Name = m.Name,
CreateTime = m.CreateTime
}).ToListAsync());
}
}
public ActionResult Detail(string ma)
{
ProviderModel model = new ProviderModel();
if (!string.IsNullOrEmpty(ma))
{
model = new ProviderDao().detail(ma);
model.IsUpdate = true;
}
return(PartialView("_DetailProvider", model));
}
public async Task <DTO.Master.ProviderDto> GetOneProviderById(Guid providerId)
{
using (IDAL.Master.IProviderDao providerDao = new ProviderDao())
{
return(await providerDao.GetAllAsync()
.Where(m => m.Id == providerId)
.Select(m => new DTO.Master.ProviderDto()
{
Id = m.Id,
Name = m.Name,
CreateTime = m.CreateTime,
}).FirstAsync());
}
}
public static bool Update(ProviderDto dto)
{
ProviderDto oldDto = allNotDeletedProviders.FirstOrDefault(n => n.ProviderId == dto.ProviderId);
bool result = ProviderDao.Update(dto);
if (result)
{
if (oldDto != null)
{
allNotDeletedProviders.Remove(oldDto);
}
allNotDeletedProviders.Add(dto);
allNotDeletedProviders = allNotDeletedProviders.OrderBy(n => n.ProviderId).ToList();
}
return(result);
}
public ActionResult ListNCC(int ma)
{
List <tbl_NCC> model = new List <tbl_NCC>();
if (ma == 0)
{
model = new ProviderDao().load();
}
else if (ma == 1)
{
model = new ProviderDao().load().Where(m => m.Hang_Hoa != null).ToList();
}
else
{
model = new ProviderDao().load().Where(m => m.Dich_Vu != null).ToList();
}
return(Json(new { data = model }, JsonRequestBehavior.AllowGet));
}
public ActionResult Save(ProviderModel model)
{
if (ModelState.IsValid)
{
bool status = false;
if (model.IsUpdate)
{
status = new ProviderDao().Update(model);
return(Json(new { status = status }, JsonRequestBehavior.AllowGet));
}
else
{
status = new ProviderDao().Save(model);
return(Json(new { status = status }, JsonRequestBehavior.AllowGet));
}
}
return(PartialView("_DetailProvider", model));
}
public static int GetPublisherId(string name)
{
if (providerList == null || providerList.Count == 0)
{
providerList = ProviderDao.Where(n => n.IsDeleted == false).ToList();
}
ProviderDto dto = providerList.FirstOrDefault(n => n.Name.Equals(name));
if (dto == null)
{
dto = ProviderDao.Where(n => n.Name.Equals(name)).ToList().FirstOrDefault();
}
if (dto == null)
{
return(0);
}
else
{
return(dto.ProviderId);
}
}
public List <Provider> ObterTodos()
{
var providerDao = new ProviderDao();
return(providerDao.ObterTodos());
}
public void Delete(int id)
{
var providerDao = new ProviderDao();
providerDao.Deletar(id);
}
public Provider ObterPorId(int id)
{
var providerDao = new ProviderDao();
return(providerDao.ObeterPorId(id));
}
public ProviderService(ILogger <ProviderService> logger, ProviderDao providerDao)
{
_logger = logger;
_providerDao = providerDao;
}
public void RunJob()
{
IPrincipal oldPrincipal = null;
try
{
oldPrincipal = Thread.CurrentPrincipal;
}
catch
{
}
try
{
if (_principal != null)
{
Thread.CurrentPrincipal = _principal;
}
CoreContext.TenantManager.SetCurrentTenant(CurrentTenant);
Thread.CurrentThread.CurrentCulture = CultureInfo.GetCultureInfo(_culture);
Thread.CurrentThread.CurrentUICulture = CultureInfo.GetCultureInfo(_culture);
FolderDao = Global.DaoFactory.GetFolderDao();
FileDao = Global.DaoFactory.GetFileDao();
TagDao = Global.DaoFactory.GetTagDao();
Logger = Global.Logger;
ProviderDao = Global.DaoFactory.GetProviderDao();
FilesSecurity = new FileSecurity(Global.DaoFactory);
try
{
_step = InitProgressStep();
}
catch
{
}
Do();
}
catch (AuthorizingException authError)
{
Error = FilesCommonResource.ErrorMassage_SecurityException;
Logger.Error(Error, new SecurityException(Error.ToString(), authError));
}
catch (Exception error)
{
Error = error.Message;
Logger.Error(error, error);
}
finally
{
IsCompleted = true;
Percentage = 100;
try
{
if (oldPrincipal != null)
{
Thread.CurrentPrincipal = oldPrincipal;
}
FolderDao.Dispose();
FileDao.Dispose();
TagDao.Dispose();
ProviderDao.Dispose();
}
catch
{
}
}
}
private void DeleteFolders(IEnumerable <object> folderIds)
{
foreach (var folderId in folderIds)
{
CancellationToken.ThrowIfCancellationRequested();
var folder = FolderDao.GetFolder(folderId);
object canCalculate = null;
if (folder == null)
{
Error = FilesCommonResource.ErrorMassage_FolderNotFound;
}
else if (folder.FolderType != FolderType.DEFAULT && folder.FolderType != FolderType.BUNCH)
{
Error = FilesCommonResource.ErrorMassage_SecurityException_DeleteFolder;
}
else if (!_ignoreException && !FilesSecurity.CanDelete(folder))
{
canCalculate = FolderDao.CanCalculateSubitems(folderId) ? null : folderId;
Error = FilesCommonResource.ErrorMassage_SecurityException_DeleteFolder;
}
else
{
canCalculate = FolderDao.CanCalculateSubitems(folderId) ? null : folderId;
FileMarker.RemoveMarkAsNewForAll(folder);
if (folder.ProviderEntry && folder.ID.Equals(folder.RootFolderId))
{
if (ProviderDao != null)
{
ProviderDao.RemoveProviderInfo(folder.ProviderId);
FilesMessageService.Send(folder, _headers, MessageAction.ThirdPartyDeleted, folder.ID.ToString(), folder.ProviderKey);
}
ProcessedFolder(folderId);
}
else
{
var immediately = _immediately || !FolderDao.UseTrashForRemove(folder);
if (immediately && FolderDao.UseRecursiveOperation(folder.ID, null))
{
DeleteFiles(FileDao.GetFiles(folder.ID));
DeleteFolders(FolderDao.GetFolders(folder.ID).Select(f => f.ID).ToList());
if (FolderDao.IsEmpty(folder.ID))
{
FolderDao.DeleteFolder(folder.ID);
FilesMessageService.Send(folder, _headers, MessageAction.FolderDeleted, folder.Title);
ProcessedFolder(folderId);
}
}
else
{
var files = FileDao.GetFiles(folder.ID, new OrderBy(SortedByType.AZ, true), FilterType.FilesOnly, false, Guid.Empty, string.Empty, false, true);
string tmpError;
if (!_ignoreException && WithError(files, true, out tmpError))
{
Error = tmpError;
}
else
{
if (immediately)
{
FolderDao.DeleteFolder(folder.ID);
FilesMessageService.Send(folder, _headers, MessageAction.FolderDeleted, folder.Title);
}
else
{
FolderDao.MoveFolder(folder.ID, _trashId, CancellationToken);
FilesMessageService.Send(folder, _headers, MessageAction.FolderMovedToTrash, folder.Title);
}
ProcessedFolder(folderId);
}
}
}
}
ProgressStep(canCalculate);
}
}
private void DeleteFolders(List <object> folderIds)
{
foreach (var folderId in folderIds)
{
CancellationToken.ThrowIfCancellationRequested();
var folder = FolderDao.GetFolder(folderId);
if (folder == null)
{
Error = FilesCommonResource.ErrorMassage_FolderNotFound;
}
else if (!ignoreException && !FilesSecurity.CanDelete(folder))
{
Error = FilesCommonResource.ErrorMassage_SecurityException_DeleteFolder;
}
else
{
FileMarker.RemoveMarkAsNewForAll(folder);
if (FolderDao.UseTrashForRemove(folder))
{
var files = FileDao.GetFiles(folder.ID, true);
if (!ignoreException && files.Exists(FileTracker.IsEditing))
{
Error = FilesCommonResource.ErrorMassage_SecurityException_DeleteEditingFolder;
}
else
{
FolderDao.MoveFolder(folder.ID, trashId);
FilesMessageService.Send(folder, headers, MessageAction.FolderMovedToTrash, folder.Title);
ProcessedFolder(folderId);
}
}
else
{
if (FolderDao.UseRecursiveOperation(folder.ID, null))
{
DeleteFiles(FileDao.GetFiles(folder.ID, false));
DeleteFolders(FolderDao.GetFolders(folder.ID).Select(f => f.ID).ToList());
if (FolderDao.GetItemsCount(folder.ID, true) == 0)
{
FolderDao.DeleteFolder(folder.ID);
ProcessedFolder(folderId);
}
}
else
{
if (folder.ProviderEntry && folder.ID.Equals(folder.RootFolderId))
{
ProviderDao.RemoveProviderInfo(folder.ProviderId);
}
else
{
FolderDao.DeleteFolder(folder.ID);
}
ProcessedFolder(folderId);
}
}
}
ProgressStep();
}
}
