Example #1
0
        private static string GetFileName(FileEnum fileEnum, string fileName, string extendName, out string dir)
        {
            Guid guid = Guid.NewGuid();

            dir = string.Empty;
            switch (fileEnum)
            {
            case FileEnum.EventAttachment:
                dir = $"\\eventattachment\\";
                break;

            case FileEnum.DataAttachment:
                dir = $"\\datasourceattachment\\";
                break;

            case FileEnum.EventScoreAttachment:
                dir = $"\\eventscoreattachment\\";
                break;

            case FileEnum.MemberHead:
                fileName = guid.ToString().FileMd5();
                dir      = $"\\memberhead\\";
                break;

            default:
                return("");
            }
            return($"{fileName}{extendName}");
        }
Example #2
0
        public void MovePiece(RankEnum rankFrom, FileEnum fileFrom, RankEnum rankTo, FileEnum fileTo)
        {
            Pieces piece = GetPiece(rankFrom, fileFrom);

            SetPiece(rankFrom, fileFrom, Pieces.NONE);
            SetPiece(rankTo, fileTo, piece);
        }
        /// <summary>
        /// compute sim btw src and tgt
        /// </summary>
        /// <param name="inSrc">in matrix format</param>
        /// <param name="inTgt">in matrix format</param>
        /// <param name="outScore"></param>
        public void PredictingV0(string inSrc, string inTgt, string outScore)
        {
            StreamWriter sw = new StreamWriter(outScore);

            int n = 0;

            foreach (Pair <string, string> p in
                     PairEnum <string, string> .E(FileEnum.GetLines(inSrc), FileEnum.GetLines(inTgt)))
            {
                double sim = 0;

                if (p.First.Trim() != "" && p.Second.Trim() != "")
                {
                    sim = CosineSim(p.First.Trim(), p.Second.Trim());
                }

                // UInt32 score = (UInt32)((1 + sim) / 2.0 * Int32.MaxValue);
                sw.WriteLine(sim);
                n++;
                if (n % 1000 == 0)
                {
                    Console.Write("{0}\r", n);
                }
            }

            sw.Close();
        }
Example #4
0
    void OnGUI()
    {
        EditorGUILayout.BeginHorizontal();
        if (GUILayout.Button("读取文件(*.csv)"))
        {
            fileName = EditorUtility.OpenFilePanel("", Application.dataPath, "csv");
            content  = File.ReadAllText(fileName);
        }

        te = (TargetEnum)EditorGUILayout.EnumPopup("平台", te);
        if (te == TargetEnum.Android)
        {
            target = BuildTarget.Android;
        }
        else if (te == TargetEnum.iOS)
        {
            target = BuildTarget.iOS;
        }

        fe = (FileEnum)EditorGUILayout.EnumPopup("文本列表名", fe);
        EditorGUILayout.EndHorizontal();

        EditorGUILayout.BeginHorizontal();
        EditorGUILayout.LabelField(fileName);
        if (GUILayout.Button("生成AssetBundle"))
        {
            BuildFiles();
        }
        EditorGUILayout.EndHorizontal();
    }
Example #5
0
        public void SetPiece(RankEnum rank, FileEnum file, Pieces piece)
        {
            DataRow row = GetBoardDataRow(rank, file);

            if (row != null)
            {
                row[Board.Piece] = piece.ToString("d");
            }
        }
Example #6
0
        public static string getNameFromFileEnum(FileEnum fileEnum)
        {
            switch (fileEnum)
            {
            case FileEnum.Chrome:
                return("Google Chrome");

            case FileEnum.Firefox:
                return("Mozilla Firefox");

            case FileEnum.Opera:
                return("Opera Launcher");

            case FileEnum.Edge:
                return("Microsoft Edge");

            case FileEnum.InternetEx:
                return("Internet Explorer");

            case FileEnum.Discord:
                return("Discord");

            case FileEnum.Spotify:
                return("Spotify");

            case FileEnum.VisualStudio:
                return("Microsoft Visual Studio");

            case FileEnum.Eclipse:
                return("Eclipse IDE");

            case FileEnum.Steam:
                return("Steam");

            case FileEnum.Word:
                return("Microsoft Office Word");

            case FileEnum.Outlook:
                return("Microsoft Outlook");

            case FileEnum.Excel:
                return("Mircosoft Office Excel");

            case FileEnum.Itunes:
                return("Itunes");

            case FileEnum.Audacity:
                return("Audacity");

            case FileEnum.Twitch:
                return("Twitch");

            default:
                return(null);
            }
        }
Example #7
0
        public static string getImageNameFromFileEnum(FileEnum fileEnum)
        {
            switch (fileEnum)
            {
            case FileEnum.Chrome:
                return("chrome");

            case FileEnum.Firefox:
                return("firefox");

            case FileEnum.Opera:
                return("opera");

            case FileEnum.Edge:
                return("edge");

            case FileEnum.InternetEx:
                return("internetexplorer");

            case FileEnum.Discord:
                return("discord");

            case FileEnum.Spotify:
                return("spotify");

            case FileEnum.VisualStudio:
                return("visualstudio");

            case FileEnum.Eclipse:
                return("eclipse");

            case FileEnum.Steam:
                return("steam");

            case FileEnum.Word:
                return("word");

            case FileEnum.Outlook:
                return("outlook");

            case FileEnum.Excel:
                return("excel");

            case FileEnum.Itunes:
                return("itunes");

            case FileEnum.Audacity:
                return("audacity");

            case FileEnum.Twitch:
                return("twitch");

            default:
                return(null);
            }
        }
Example #8
0
        private DataRow GetBoardDataRow(RankEnum rank, FileEnum file)
        {
            DataRow[] rows = BoardData.Select("r=" + rank.ToString("d") + " AND f=" + file.ToString("d"));

            if (rows.Length > 0)
            {
                return(rows[0]);
            }

            return(null);
        }
Example #9
0
        private void openProgramLocation_Click(object sender, EventArgs e)
        {
            using (OpenFileDialog openFileDialog1 = new OpenFileDialog())
            {
                if (exeLoc == "")
                {
                    openFileDialog1.InitialDirectory = "c:\\";
                }
                else
                {
                    openFileDialog1.InitialDirectory = exeLoc;
                }

                openFileDialog1.Filter           = "exe Files (*.exe)|*.exe|jar Files (*.jar)|*.jar|All files (*.*)|*.*";
                openFileDialog1.FilterIndex      = 0;
                openFileDialog1.RestoreDirectory = true;

                if (openFileDialog1.ShowDialog() == DialogResult.OK)
                {
                    exeLoc           = openFileDialog1.FileName;
                    programText.Text = exeLoc;
                    imgLoc           = openFileDialog1.FileName;
                    imgLocText.Text  = imgLoc;

                    if (nameTextBox.Text == "")
                    {
                        string exe = exeLoc.Split('\\')[exeLoc.Split('\\').Length - 1];
                        exe = Regex.Replace(exe, ".exe", "");
                        exe = Regex.Replace(exe, ".jar", "");
                        exe = Regex.Replace(exe, ".bat", "");
                        exe = UtilMethods.FirstLetterToUpperCaseOrConvertNullToEmptyString(exe);
                        nameTextBox.Text = exe;
                    }

                    FileEnum fileEnum = UtilMethods.hasHighQualityIcon(UtilMethods.getFileName(exeLoc));
                    if (fileEnum != FileEnum.None)
                    {
                        DialogResult dialogResult = MessageBox.Show("Do you want to display a high quality icon for " +
                                                                    UtilMethods.getNameFromFileEnum(fileEnum) +
                                                                    " or not?", "High Quality Icon", MessageBoxButtons.YesNo);
                        if (dialogResult == DialogResult.Yes)
                        {
                            imgLoc          = "resources:" + UtilMethods.getImageNameFromFileEnum(fileEnum);
                            imgLocText.Text = imgLoc;
                        }
                        else if (dialogResult == DialogResult.No)
                        {
                            //do something else
                        }
                    }
                }
            }
        }
Example #10
0
        private void AddBoardRow(string singleNotation, Pieces piece)
        {
            DataRow  dr   = BoardData.NewRow();
            RankEnum rank = GetRank(singleNotation);
            FileEnum file = GetFile(singleNotation);

            dr["r"] = rank.ToString("d");
            dr["f"] = file.ToString("d");
            dr["p"] = piece.ToString("d");

            BoardData.Rows.Add(dr);
        }
Example #11
0
        public FileEnum GetFile(string singleNotation)
        {
            FileEnum fileEnum = FileEnum.NoFile;
            string   file     = singleNotation.Substring(0, 1);

            switch (file)
            {
            case "a":
                fileEnum = FileEnum.FileA;
                break;

            case "b":
                fileEnum = FileEnum.FileB;
                break;

            case "c":
                fileEnum = FileEnum.FileC;
                break;

            case "d":
                fileEnum = FileEnum.FileD;
                break;

            case "e":
                fileEnum = FileEnum.FileE;
                break;

            case "f":
                fileEnum = FileEnum.FileF;
                break;

            case "g":
                fileEnum = FileEnum.FileG;
                break;

            case "h":
                fileEnum = FileEnum.FileH;
                break;

            default:
                fileEnum = FileEnum.NoFile;
                break;
            }
            return(fileEnum);
        }
Example #12
0
        public string GetFileString(FileEnum file)
        {
            string fileString = string.Empty;

            switch (file)
            {
            case FileEnum.FileA:
                fileString = "a";
                break;

            case FileEnum.FileB:
                fileString = "b";
                break;

            case FileEnum.FileC:
                fileString = "c";
                break;

            case FileEnum.FileD:
                fileString = "d";
                break;

            case FileEnum.FileE:
                fileString = "e";
                break;

            case FileEnum.FileF:
                fileString = "f";
                break;

            case FileEnum.FileG:
                fileString = "g";
                break;

            case FileEnum.FileH:
                fileString = "h";
                break;

            default:
                break;
            }

            return(fileString);
        }
Example #13
0
        public async Task <IEnumerable <AddFileResponse> > AddFilesAsync(string bucketName, IList <IFormFile> formFiles, FileEnum fileType)
        {
            var response = new List <AddFileResponse>();

            foreach (var file in formFiles)
            {
                var         fileName = "";
                S3CannedACL acl      = null;
                switch (fileType)
                {
                case FileEnum.ProductImage:
                    fileName = $"Images/Products/{file.FileName}";
                    acl      = S3CannedACL.PublicRead;
                    break;

                case FileEnum.UserImage:
                    fileName = $"Images/Users/{file.FileName}";
                    acl      = S3CannedACL.PublicRead;
                    break;

                case FileEnum.UserDocument:
                    fileName = $"Documents/UserDocuments/{file.FileName}";
                    acl      = S3CannedACL.NoACL;
                    break;

                case FileEnum.IdentityDocument:
                    fileName = $"Documents/IdentityDocuments/{file.FileName}";
                    acl      = S3CannedACL.NoACL;
                    break;

                default: return(null);
                }

                var requestUpload = new TransferUtilityUploadRequest
                {
                    //add custom folder structure for uniqueness
                    Key         = fileName,
                    CannedACL   = acl,
                    InputStream = file.OpenReadStream(),
                    BucketName  = bucketName
                };
                using (var transferUtility = new TransferUtility(_s3Client)) {
                    await transferUtility.UploadAsync(requestUpload);
                };
                var expiryUrl = new GetPreSignedUrlRequest {
                    BucketName = bucketName,
                    Key        = file.FileName,
                    Expires    = DateTime.Now.AddDays(1)
                };
                var url       = _s3Client.GetPreSignedURL(expiryUrl);
                var objectUrl = $"https://{bucketName}.s3.amazonaws.com/{fileName}";
                response.Add(new AddFileResponse {
                    preConfiguredUrl = url,
                    ActualObjectUrl  = objectUrl
                });
            }

            return(response);
        }
Example #14
0
        public async Task <ActionResult <IEnumerable <AddFileResponse> > > Add(string bucketName, IList <IFormFile> formFiles, [FromForm] FileEnum fileType)
        {
            if (formFiles == null)
            {
                return(BadRequest("There are no provided files for upload!"));
            }
            var result = await _filesRepo.AddFilesAsync(bucketName, formFiles, fileType);

            if (result == null)
            {
                return(BadRequest("unable to creat upload files at this time"));
            }

            return(Ok(result));
        }
        /// <summary>
        /// compute sim btw src and tgt
        /// </summary>
        /// <param name="inTSV">input labeled data file</param>
        /// <param name="inSrc">in vector format</param>
        /// <param name="inTgt">in vector format</param>
        /// <param name="FeatName">feature name</param>
        /// <param name="outTSV">output score file</param>
        /// <param name="bOutputVector">whether to output vector</param>
        public void PredictingV1(string inTSV, string inSrc, string inTgt, string FeatName, string outTSV, bool bOutputVector)
        {
            StreamWriter sw = new StreamWriter(outTSV);
            StreamReader sr = null;

            if (inTSV != "")
            {
                sr = new StreamReader(inTSV);
            }

            Console.WriteLine("computing sim...");
            string sLine = "";
            int    n     = 0;

            if (sr != null)
            {
                sLine = sr.ReadLine();

                sw.Write("{0}\t{1}", sLine, FeatName);
                if (bOutputVector)
                {
                    for (int i = 0; i < m_SrcModel.NumOutputNode; ++i)
                    {
                        sw.Write("\t{0}_s{1}", FeatName, i);
                    }
                    for (int i = 0; i < m_TgtModel.NumOutputNode; ++i)
                    {
                        sw.Write("\t{0}_t{1}", FeatName, i);
                    }
                }
                sw.Write("\n");
            }

            sLine = "";
            foreach (Pair <string, string> p in PairEnum <string, string> .E(FileEnum.GetLines(inSrc), FileEnum.GetLines(inTgt)))
            {
                if (sr != null)
                {
                    sLine = sr.ReadLine();
                }

                List <Dictionary <int, double> > srcMt = TextUtils.String2Matrix(p.First);
                List <Dictionary <int, double> > tgtMt = TextUtils.String2Matrix(p.Second);
                double[] srcVt = m_SrcModel.Fprop(srcMt);
                double[] tgtVt = m_TgtModel.Fprop(tgtMt);
                double   sim   = NNModelUtils.CosineSim(srcVt, tgtVt);

                if (sr != null)
                {
                    sw.Write("{0}\t{1}", sLine, (float)sim);
                }
                else
                {
                    sw.Write((float)sim);
                }

                if (bOutputVector)
                {
                    for (int i = 0; i < m_SrcModel.NumOutputNode; ++i)
                    {
                        sw.Write("\t{0}", (float)srcVt[i]);
                    }
                    for (int i = 0; i < m_TgtModel.NumOutputNode; ++i)
                    {
                        sw.Write("\t{0}", (float)tgtVt[i]);
                    }
                }
                sw.Write("\n");

                n++; if (n % 1000 == 0)
                {
                    Console.Error.Write("{0}\r", n);
                }
            }
            Console.WriteLine("{0} pairs.", n);

            sw.Close();
            if (sr != null)
            {
                sr.Close();
            }
        }
Example #16
0
 public bool Play(FileEnum fileType)
 {
     if (fileType == FileEnum.MP3)
         return true;
     return false;
 }
Example #17
0
 public bool Play(FileEnum fileType)
 {
     return PlaySubject.PlaySub.Play(fileType);
 }
Example #18
0
        public Pieces GetPiece(RankEnum rank, FileEnum file)
        {
            DataRow row = GetBoardDataRow(rank, file);

            return((Pieces)BaseItem.GetColInt32(row, Board.Piece));
        }