Esempio n. 1
0
        public void UpdateBranch(BranchDto branchDto, long restaurantAdminId)
        {
            ValidateBranch(branchDto, restaurantAdminId);
            var branch = _branchService.Find(branchDto.BranchId);

            if (branch == null)
            {
                throw new NotFoundException(ErrorCodes.BranchNotFound);
            }
            foreach (var branchTitle in branchDto.BranchTitleDictionary)
            {
                var branchTranslation =
                    branch.BranchTranslations.FirstOrDefault(x => x.Language.ToLower() == branchTitle.Key.ToLower());
                if (branchTranslation == null)
                {
                    branch.BranchTranslations.Add(new BranchTranslation
                    {
                        Language      = branchTitle.Key.ToLower(),
                        BranchTitle   = branchTitle.Value,
                        BranchAddress = branchDto.BranchAddressDictionary[branchTitle.Key]
                    });
                }
                else
                {
                    branchTranslation.BranchTitle   = branchTitle.Value;
                    branchTranslation.BranchAddress = branchDto.BranchAddressDictionary[branchTitle.Key];
                }
            }
            _branchService.Update(branch);
            SaveChanges();
        }
Esempio n. 2
0
        public ActionResult BranchChartData(int?companyId)
        {
            BranchDto dto = new BranchDto()
            {
                CompanyName   = "21st Century Salvage",
                BranchRecords = new List <BranchRecord>()
                {
                    new BranchRecord()
                    {
                        BranchName = "B052", PreviousYearRevenue = 0, CurrentYearRevenue = 0,
                    },
                    new BranchRecord()
                    {
                        BranchName = "B057", PreviousYearRevenue = 7595, CurrentYearRevenue = 65602,
                    },
                    new BranchRecord()
                    {
                        BranchName = "B063", PreviousYearRevenue = 0, CurrentYearRevenue = 0,
                    },
                    new BranchRecord()
                    {
                        BranchName = "B068", PreviousYearRevenue = 0, CurrentYearRevenue = 10205,
                    },
                    new BranchRecord()
                    {
                        BranchName = "B087", PreviousYearRevenue = 0, CurrentYearRevenue = 0,
                    },
                    new BranchRecord()
                    {
                        BranchName = "B089", PreviousYearRevenue = 0, CurrentYearRevenue = 0,
                    },
                    new BranchRecord()
                    {
                        BranchName = "B301", PreviousYearRevenue = 0, CurrentYearRevenue = 0,
                    },
                    new BranchRecord()
                    {
                        BranchName = "B307", PreviousYearRevenue = 0, CurrentYearRevenue = 0,
                    },
                    new BranchRecord()
                    {
                        BranchName = "B309", PreviousYearRevenue = 0, CurrentYearRevenue = 0,
                    },
                    new BranchRecord()
                    {
                        BranchName = "B339", PreviousYearRevenue = 249260, CurrentYearRevenue = 240060,
                    },
                    new BranchRecord()
                    {
                        BranchName = "Other", PreviousYearRevenue = 0, CurrentYearRevenue = 0,
                    },
                    new BranchRecord()
                    {
                        BranchName = "0", PreviousYearRevenue = 0, CurrentYearRevenue = 0,
                    },
                }
            };

            return(Json(dto));
        }
Esempio n. 3
0
        // Matrixnet
        public async Task <ResultObject> CreateBranchFromExcelAsync(string path, BranchDto branchDto)
        {
            ResultObject resultObject = new ResultObject();
            var          branch       = _mapper.Map <Branch>(branchDto);

            branch.UserBranches.Add(new UserBranches()
            {
                BranchId = branch.ID,
                UserId   = ConstUserIDs.Administrator
            });

            System.Text.Encoding.RegisterProvider(System.Text.CodePagesEncodingProvider.Instance);
            using (var stream = File.Open(path, FileMode.Open, FileAccess.Read))
            {
                using (var reader = ExcelReaderFactory.CreateReader(stream))
                {
                    do
                    {
                        while (reader.Read()) //Each ROW
                        {
                            for (int column = 0; column < reader.FieldCount; column++)
                            {
                                //Console.WriteLine(reader.GetString(column));//Will blow up if the value is decimal etc.
                                Console.WriteLine(reader.GetValue(column));//Get Value returns object
                            }
                        }
                    } while (reader.NextResult()); //Move to NEXT SHEET
                }
            }

            resultObject.Result = branchDto;
            return(resultObject);
        }
Esempio n. 4
0
        public async Task <ResultObject> CreateBranchAsync(BranchDto branchDto)
        {
            ResultObject resultObject = new ResultObject();
            //var resultObject = await _accountService.GetBankAccountAmountAsync(0, branchDto.BDN);
            //if (resultObject.ServerErrors.Count > 0)
            //    return resultObject;
            //resultObject.ServerErrors = null;
            //decimal bdnAmount = resultObject.Result == null ? 0 : (decimal)resultObject.Result;
            var branch = _mapper.Map <Branch>(branchDto);

            branch.UserBranches.Add(new UserBranches()
            {
                BranchId = branch.ID,
                UserId   =
                    ConstUserIDs.Administrator
            });

            SetZoneIdForBranch(ref branchDto, ref branch);
            await _branchService.CreateBranchAsync(branch);

            var rsult = await _transactionManager.SaveAllAsync();

            resultObject.Result = branchDto;
            return(resultObject);
        }
Esempio n. 5
0
 private void ValidateBranch(BranchDto branchDto, long restaurantAdminId)
 {
     foreach (var branchTitle in branchDto.BranchTitleDictionary)
     {
         if (string.IsNullOrEmpty(branchTitle.Value))
         {
             throw new ValidationException(ErrorCodes.EmptyBranchTitle);
         }
         if (branchTitle.Value.Length > 300)
         {
             throw new ValidationException(ErrorCodes.BranchTiteExceedLength);
         }
         if (_branchTranslationService.CheckBranchTitleExist(branchTitle.Value, branchTitle.Key, branchDto.BranchId, restaurantAdminId)
             )
         {
             throw new ValidationException(ErrorCodes.BranchTitleAlreadyExist);
         }
     }
     foreach (var branchAddress in branchDto.BranchAddressDictionary)
     {
         if (string.IsNullOrEmpty(branchAddress.Value))
         {
             throw new ValidationException(ErrorCodes.EmptyBranchAddress);
         }
         if (branchAddress.Value.Length > 300)
         {
             throw new ValidationException(ErrorCodes.BranchAddressExceedLength);
         }
     }
 }
Esempio n. 6
0
        public void AddBranch(BranchDto branchDto, long restaurantAdminId)
        {
            var restaurant = _restaurantService.GetRestaurantByAdminId(restaurantAdminId);

            if (restaurant == null)
            {
                throw new NotFoundException(ErrorCodes.RestaurantNotFound);
            }
            if (restaurant.IsDeleted)
            {
                throw new ValidationException(ErrorCodes.RestaurantDeleted);
            }
            ValidateBranch(branchDto, restaurantAdminId);

            var branch = Mapper.Map <Branch>(branchDto);

            branch.RestaurantId = restaurant.RestaurantId;
            foreach (var branchTitle in branchDto.BranchTitleDictionary)
            {
                branch.BranchTranslations.Add(new BranchTranslation
                {
                    BranchTitle   = branchTitle.Value,
                    BranchAddress = branchDto.BranchAddressDictionary[branchTitle.Key],
                    Language      = branchTitle.Key.ToLower()
                });
            }
            _branchTranslationService.InsertRange(branch.BranchTranslations);
            _branchService.Insert(branch);
            SaveChanges();
        }
Esempio n. 7
0
        public bool UpdateBranch(BranchDto newBranchDetails)
        {
            var oldBranchDetails     = FindBranchById(newBranchDetails.BranchId);
            var updatedBranchDetails = newBranchDetails.DtoToEntity();

            updatedBranchDetails.BranchID    = newBranchDetails.BranchId;
            updatedBranchDetails.DateUpdated = System.DateTime.Now;

            updatedBranchDetails.CreatedBy   = oldBranchDetails.CreatedBy;
            updatedBranchDetails.CreatedDate = oldBranchDetails.CreatedDate;

            //updatedBranchDetails = new Branch()
            //{
            //    CreatedBy = oldBranchDetails.CreatedBy,
            //    CreatedDate = oldBranchDetails.CreatedDate,
            //    BranchID = newBranchDetails.BranchId
            //};

            //BranchName = newBranchDetails.BranchName.ToUpper(),
            //    BranchAddress = newBranchDetails.BranchAddress,
            //    BranchDetails = newBranchDetails.BranchDetails,
            //    UpdatedBy = newBranchDetails.UpdatedBy,
            //    DateUpdated = System.DateTime.Now,

            if (this._branch.Update2(updatedBranchDetails).IsNull())
            {
                return(false);
            }


            return(true);
        }
        public async Task <IList <BranchDto> > GetBranchesAsync(string projectId)
        {
            await _commonValidator.ProjectHaveToExists(projectId);

            var branchesNames = await _fileSystemService.GetBranchesNamesAsync(projectId);

            var branches = new List <BranchDto>();

            foreach (var branchName in branchesNames)
            {
                try
                {
                    string mkDocsYaml = await _fileSystemService.ReadTextAsync(projectId, branchName, "mkdocs.yml");

                    var branch = new BranchDto
                    {
                        Name       = branchName,
                        MkDocsYaml = mkDocsYaml
                    };

                    branches.Add(branch);
                }
                catch (FileNotFoundException)
                {
                    _logger.LogWarning($"Branch '{branchName}' in project '{projectId}' doesn't have mkdocs file.");
                }
            }

            branches = branches.OrderBy(x => x.Name).ToList();
            return(branches);
        }
Esempio n. 9
0
        private ResultDto InsertUpdateBranchMaster(BranchDto branchDto)
        {
            ResultDto resultDto = new ResultDto();
            string    obectName = "branch";

            try
            {
                ObjectParameter prmBranchId   = new ObjectParameter("BranchID", branchDto.BranchID);
                ObjectParameter prmBranchCode = new ObjectParameter("BranchCode", string.Empty);
                int             effectedRow   = _dbContext.uspBranchInsertUpdate(prmBranchId, branchDto.BranchName, branchDto.TEBranchName, branchDto.StartDate, branchDto.Phone,
                                                                                 branchDto.Email, branchDto.Address, branchDto.AccountantID, branchDto.AccountantFromDate, branchDto.ManagerID, branchDto.ManagerFromDate, branchDto.UserID, prmBranchCode);

                resultDto.ObjectId   = (int)prmBranchId.Value;
                resultDto.ObjectCode = string.IsNullOrEmpty((string)prmBranchCode.Value) ? branchDto.BranchCode : (string)prmBranchCode.Value;

                if (resultDto.ObjectId > 0)
                {
                    resultDto.Message = string.Format("{0} details saved successfully with code : {1}", obectName, resultDto.ObjectCode);
                }
                else if (resultDto.ObjectId == -1)
                {
                    resultDto.Message = string.Format("Error occured while generating {0} code", obectName);
                }
                else
                {
                    resultDto.Message = string.Format("Error occured while saving {0} details", obectName);
                }
            }
            catch (Exception)
            {
                resultDto.Message  = string.Format("Service layer error occured while saving the {0} details", obectName);
                resultDto.ObjectId = -98;
            }
            return(resultDto);
        }
Esempio n. 10
0
        public async Task <ContentResult> CreateOrUpdateBranch(BranchDto branchDto)
        {
            ReturnMessage returnmessage = new ReturnMessage(1, "Branch Saved Succesfully");

            try
            {
                var branch = await Task.Run(() => _unitOfWork.Branchs.GetAsync(filter: w => w.Id == branchDto.Id));

                var branchToAdd = _mapper.Map <Branch>(branchDto);
                if (branch.Count() == 0)
                {
                    branchToAdd.Id = 0;
                    _unitOfWork.Branchs.Add(branchToAdd);
                }
                else
                {
                    _unitOfWork.Branchs.Update(branchToAdd);
                }
                var status = _unitOfWork.Complete();
                _logger.LogInformation("Log:Add Branch for ID: {Id}", branchToAdd.Id);
                return(this.Content(returnmessage.returnMessage(null),
                                    "application/json"));
            }
            catch (Exception ex)
            {
                returnmessage.msg     = ex.Message.ToString();
                returnmessage.msgCode = -3;
                return(this.Content(returnmessage.returnMessage(null)));
            }
        }
Esempio n. 11
0
        public async Task <HttpResponseMessage> Post(string projectId, BranchDto branch)
        {
            AssertIfServiceNotAlive();

            RestClient <BranchDto> baseClient = GetRestClient(projectId);

            return(await baseClient.Post(branch));
        }
Esempio n. 12
0
        public BranchDto GetByID(int branchId)
        {
            var objuspBranchGetByIdResult = _dbContext.uspBranchGetById(branchId).ToList().FirstOrDefault();

            BranchDto objBranchDto = AutoMapperEntityConfiguration.Cast <BranchDto>(objuspBranchGetByIdResult);

            return(objBranchDto);
        }
Esempio n. 13
0
        private async Task UpdateAsync(BranchDto input)
        {
            if (input.Id != null)
            {
                var branch = await _branchRepository.FirstOrDefaultAsync((int)input.Id);

                ObjectMapper.Map(input, branch);
            }
        }
Esempio n. 14
0
        public ActionResult PointRateSetup(BranchDto branchDto)
        {
            var targetBranch = db.Branches.ToList().FirstOrDefault();

            targetBranch.PointRate = branchDto.PointRate;
            targetBranch.SetModifiedData(User.Identity.GetUserId());
            db.SaveChanges();

            ViewBag.UserId = User.Identity.GetUserId(); return(RedirectToAction("PointRateSetup"));
        }
Esempio n. 15
0
        public bool SaveBranch(BranchDto branchDetails)
        {
            this.branch = branchDetails.DtoToEntity();

            if (this._branch.Insert(this.branch).IsNull())
            {
                return(false);
            }
            return(true);
        }
Esempio n. 16
0
 public async Task <ResultObject> CreateBranchFromExcelAsync([FromBody] BranchDto branchDto)
 {
     if (branchDto.ID == 0)
     {
         return(await branchAppService.CreateBranchFromExcelAsync(@"", branchDto));
     }
     return(new ResultObject {
         Result = branchDto, ServerErrors = null
     });
 }
Esempio n. 17
0
        public void Update(BranchDto branchData)
        {
            var branchObject = UnitOfWork.BranchRepository.Get(branchData.Id);

            if (branchObject != null)
            {
                branchObject.Name = branchData.Name;
            }
            UnitOfWork.SaveChanges();
        }
Esempio n. 18
0
        public async Task <ResultObject> UpdateAsync(BranchDto branchDto)
        {
            var branch = await branchAppService.UpdateBranchAsync(branchDto);

            var resultobject = new ResultObject {
                Result = branch, ServerErrors = null
            };

            return(resultobject);
        }
        public static int NewBranch(BranchDto branchDto)
        {
            Branch branch = AutoMapperConfiguration.mapper.Map <Branch>(branchDto);

            using (placementDepartmentDBEntities placementDepartmentDB = new placementDepartmentDBEntities())
            {
                branch = placementDepartmentDB.Branch.Add(branch);
                placementDepartmentDB.SaveChanges();
                return(branch.Id);
            }
        }
        public HttpResponseMessage EditBranch(Index index)
        {
            var branches  = _context.Branches.SingleOrDefault(c => c.Id == index.Id);
            var branchDto = new BranchDto()
            {
                Address = branches.Address,
                Name    = branches.Name
            };

            return(Request.CreateResponse(HttpStatusCode.OK, branchDto));
        }
        public static void editBranch(BranchDto branchDto)
        {
            Branch branch = AutoMapperConfiguration.mapper.Map <Branch>(branchDto);

            using (placementDepartmentDBEntities placementDepartmentDB = new placementDepartmentDBEntities())
            {
                placementDepartmentDB.Branch.Attach(branch);
                placementDepartmentDB.Entry(branch).State = EntityState.Modified;
                placementDepartmentDB.SaveChanges();
            }
        }
        private async Task CreateBranchAsync(string projectId, string branchName, byte[] content)
        {
            string mkdocsContent = Encoding.UTF8.GetString(content);

            var branch = new BranchDto
            {
                Name       = branchName,
                MkDocsYaml = mkdocsContent
            };
            await _branchService.CreateBranchAsync(projectId, branch);
        }
Esempio n. 23
0
 public async Task CreateOrUpdateBranch(BranchDto input)
 {
     if (input.Id == null)
     {
         await CreateAsync(input);
     }
     else
     {
         await UpdateAsync(input);
     }
 }
Esempio n. 24
0
        public ActionResult NewTask(long projectId)
        {
            BranchDto[] branches;
            try
            {
                branches = _apiService.GetBranches(projectId);
            }
            catch (Exception)
            {
                branches = new BranchDto[0];
            }

            if (branches.Length == 0)
            {
                return(PartialView(new CreateTaskViewModel
                {
                    ProjectId = projectId,
                    Branches = new List <SelectListItem>()
                }));
            }

            var latestScannedId = branches
                                  .Where(_ => _.LastScanFinishedUtc != null)
                                  .OrderByDescending(_ => _.LastScanFinishedUtc)
                                  .Select(_ => _.Id)
                                  .FirstOrDefault();

            var model = new CreateTaskViewModel
            {
                ProjectId = projectId,
                Branches  = branches.Select(_ =>
                                            new SelectListItem
                {
                    Value    = _.Id,
                    Text     = _.Name,
                    Selected = _.Id == latestScannedId
                }).ToArray()
            };

            if (model.Branches.Any(_ => _.Selected))
            {
                return(PartialView(model));
            }

            var defaultBranchId = branches.FirstOrDefault(_ => _.IsDefault);

            if (defaultBranchId != null)
            {
                model.Branches.Where(_ => _.Value == defaultBranchId.Id).ForEach(_ => _.Selected = true);
            }

            return(PartialView(model));
        }
        public async Task UpdateBranchAsync(string projectId, string branchName, BranchDto branch)
        {
            await _commonValidator.ProjectHaveToExists(projectId);

            await _commonValidator.BranchHaveToExists(projectId, branchName);

            if (!IsYamlFileCorrect(branch.MkDocsYaml))
            {
                throw new MkDocsFileIsIncorrectException($"MkDocs file is empty or has incorrect format.");
            }

            await _fileSystemService.WriteTextAsync(projectId, branchName, "mkdocs.yml", branch.MkDocsYaml);
        }
        public async Task <IActionResult> Post(string projectId, [FromBody] BranchDto branch)
        {
            var authorization = await _authorizationService.AuthorizeAsync(User, new ProjectDto { Id = projectId }, Operations.Update);

            if (!authorization.Succeeded)
            {
                return(Forbid());
            }

            await _branchesService.CreateBranchAsync(projectId, branch);

            return(Created($"/projects/{projectId}/branches/{branch.Name}", branch));
        }
Esempio n. 27
0
        public async Task CreateBranchAsync(string projectId, BranchDto branch)
        {
            var result = await _branchesClient.Post(projectId, branch);

            if (!result.IsSuccessStatusCode)
            {
                var content = await result.Content.ReadAsStringAsync();

                throw new CreateBranchException("During creating the new branch error occurs: " + content);
            }

            _cacheService.ClearBranchesCache(projectId);
        }
        public async Task <IActionResult> Put(string projectId, string branchName, [FromBody] BranchDto branch)
        {
            var authorization = await _authorizationService.AuthorizeAsync(User, new ProjectDto { Id = projectId }, Operations.Update);

            if (!authorization.Succeeded)
            {
                return(Forbid());
            }

            await _branchesService.UpdateBranchAsync(projectId, branchName, branch);

            return(Ok());
        }
Esempio n. 29
0
 public HttpResponseMessage GetBranch([FromUri] int branchId)
 {
     try
     {
         Branch    branch    = BranchManager.GetBranch(branchId, Branch.Includes.Address | Branch.Includes.BranchType | Branch.Includes.ActivityHours | Branch.Includes.Rules | Branch.Includes.Institution);
         BranchDto branchDto = Converters.Convert(branch);
         return(Request.CreateResponse(HttpStatusCode.OK, branchDto));
     }
     catch (Exception ex)
     {
         return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, $"failed to get branch {branchId},{ex.Message}"));
     }
 }
Esempio n. 30
0
        public async Task <BranchDto> UpdateBranchAsync(BranchDto branchDto)
        {
            var branch = _mapper.Map <Branch>(branchDto);

            SetZoneIdForBranch(ref branchDto, ref branch);
            var branchTask = await _branchService.UpdateBranchAsync(branch);

            await _transactionManager.SaveAllAsync();

            var finalBranchDto = _mapper.Map <BranchDto>(branchTask);

            return(finalBranchDto);
        }
Esempio n. 31
0
 /// <summary>
 /// Deletes branch over branch contract client.
 /// </summary>
 /// <param name="dto">Branch dto which has to be deleted.</param>
 public void DeleteBranch(BranchDto dto)
 {
     _bcc.DeleteBranch(dto);
 }
Esempio n. 32
0
 /// <summary>
 /// Inserts branch over branch contract client.
 /// </summary>
 /// <param name="dto">Branch dto which has to be inserted.</param>
 public void InsertBranch(BranchDto dto)
 {
     _bcc.InsertBranch(dto);
 }
Esempio n. 33
0
 /// <summary>
 /// Updates branch over branch contract client.
 /// </summary>
 /// <param name="dto">Branch dto which has to be updated.</param>
 public void UpdateBranch(BranchDto dto)
 {
     _bcc.UpdateBranch(dto);
 }
Esempio n. 34
0
 public TreeViewItem(BranchDto branchDto, String text)
 {
     this.ID = branchDto.Id;
     this.ParentID = branchDto.NodeParent;
     this.Text = text;
 }